odac 0.9.0 → 1.0.0

package/{framework/src → src}/Mysql.js

@@ -59,8 +59,8 @@ class Mysql {
 
   async #define(table) {
     return new Promise(resolve => {
-      if (!Candy.Mysql.db[this.#database]) Candy.Mysql.db[this.#database] = {}
-      this.#table[table] = Candy.Mysql.db[this.#database][table]
+      if (!Odac.Mysql.db[this.#database]) Odac.Mysql.db[this.#database] = {}
+      this.#table[table] = Odac.Mysql.db[this.#database][table]
       if (this.#table[table]) {
         this.#defining = false
         return resolve(true)
@@ -81,7 +81,7 @@ class Mysql {
         }
         if (!this.#table[table]) this.#table[table] = {}
         this.#table[table].columns = columns
-        Candy.Mysql.db[this.#database][table] = this.#table[table]
+        Odac.Mysql.db[this.#database][table] = this.#table[table]
         this.#defining = false
         return resolve(true)
       })
@@ -98,11 +98,11 @@ class Mysql {
   }
 
   #error(err, query) {
-    err = 'CandyPack Mysql Error: ' + (err?.message ?? 'Unknown error').trim() + '\n'
+    err = 'Odac Mysql Error: ' + (err?.message ?? 'Unknown error').trim() + '\n'
     if (query) err += 'Query: ' + query + '\n'
     while (this.#stack.length > 0) {
       let line = this.#stack.shift().replace('at', '')
-      if (line.includes('/node_modules/candypack/framework/src/')) break
+      if (line.includes('/node_modules/odac/framework/src/')) break
       else if (!line.includes('(node:')) err += line + '\n'
     }
     console.error(err)
@@ -163,7 +163,7 @@ class Mysql {
     //   $md5_query = md5($query);
     //   $md5_table = md5($this->arr['table']);
     //   $file = "cache/mysql/".md5(Mysql::$name)."/$md5_table"."_$md5_query";
-    //   $cache = Candy::storage($file)->get('cache');
+    //   $cache = Odac::storage($file)->get('cache');
     //   if(isset($cache->date) && ($cache->date >= (time() - $this->arr['cache']))) return $cache->data;
     // }
     let query = this.query('get')
@@ -182,7 +182,7 @@ class Mysql {
     // if(isset($cache)){
     //   $cache->data = $data;
     //   $cache->date = time();
-    //   Candy::storage($file)->set('cache', $cache);
+    //   Odac::storage($file)->set('cache', $cache);
     // }
     return data
   }
@@ -244,7 +244,7 @@ class Mysql {
     //         $md5_query = md5($query);
     //         $md5_table = md5($this->arr['table']);
     //         $file = "cache/mysql/".md5(Mysql::$name)."/$md5_table"."_$md5_query"."_r";
-    //         $cache = Candy::storage($file)->get('cache');
+    //         $cache = Odac::storage($file)->get('cache');
     //         if(isset($cache->date) && ($cache->date >= (time() - $this->arr['cache']))) return $cache->data;
     //       }
     let query = this.query('get')
@@ -254,7 +254,7 @@ class Mysql {
     //       if(isset($cache)){
     //         $cache->data = $rows;
     //         $cache->date = time();
-    //         Candy::storage($file)->set('cache', $cache);
+    //         Odac::storage($file)->set('cache', $cache);
     //       }
     return rows
   }
@@ -263,7 +263,7 @@ class Mysql {
     return new Promise(resolve => {
       if (!query) return resolve(false)
       if (!this.#conn) return resolve(false)
-      if (this.#conn.state == 'disconnected') Candy.Mysql.init()
+      if (this.#conn.state == 'disconnected') Odac.Mysql.init()
       const args = params ? [query, params] : [query]
       args.push((err, result) => {
         if (err) return resolve(this.#error(err, query))
@@ -309,7 +309,7 @@ class Mysql {
 
   groupBy(...args) {
     this.#arr['group by'] = this.#arr['group by'] ?? ''
-    let select = this.#arr['group by'].split(',')
+    let select = this.#arr['group by'] ? this.#arr['group by'].split(',') : []
     //       if(count(func_get_args())==1 && is_array(func_get_args()[0])){
     //         if(isset(func_get_args()[0]['ct']) && isset(func_get_args()[0]['v']) && func_get_args()[0]['ct'] == $GLOBALS['candy_token_mysql']){
     //           $select[] = func_get_args()[0]['v'];
@@ -407,33 +407,33 @@ class Mysql {
           break
         } else if (!this.#arr.select) {
           continue
-        } else if (Candy.Var(this.#arr.select).contains(' AS "' + col + '"')) {
+        } else if (Odac.Var(this.#arr.select).contains(' AS "' + col + '"')) {
           // $exp = explode(' ,',explode(" AS \"$col\"",$this->arr['select'])[0]);
-          //       $real_col = explode('.',Candy::var(trim(end($exp)))->clear('`'));
+          //       $real_col = explode('.',Odac::var(trim(end($exp)))->clear('`'));
           //       $real_table = trim($real_col[0]);
           //       $real_col = trim($real_col[1]);
           //       $this->types[$col] = $this->types[$col] = $this->table[$real_table]['columns'][$real_col]['Type'] ?? $this->types[$col];
           break
-        } else if (Candy.Var(this.#arr.select).containsAny(' `' + col + '`', ' `' + key + '`.`' + col + '`')) {
+        } else if (Odac.Var(this.#arr.select).containsAny(' `' + col + '`', ' `' + key + '`.`' + col + '`')) {
           this.types[col] = this.#table[key].columns[col].Type ?? this.types[col]
         }
       }
     }
     if (action == 'decode') {
-      if (Candy.Var(this.types[col]).isBegin('tinyint(1)')) value = value ? true : false
-      else if (Candy.Var(this.types[col]).isBegin('int')) value = parseInt(value)
-      else if (Candy.Var(this.types[col]).isBegin('double')) value = parseFloat(value)
-      else if (Candy.Var(this.types[col]).isBegin('float')) value = parseFloat(value)
-      else if (Candy.Var(this.types[col]).isBegin('boolean')) value = parseInt(value)
-      else if (Candy.Var(this.types[col]).isBegin('json')) value = JSON.parse(value)
+      if (Odac.Var(this.types[col]).isBegin('tinyint(1)')) value = value ? true : false
+      else if (Odac.Var(this.types[col]).isBegin('int')) value = parseInt(value)
+      else if (Odac.Var(this.types[col]).isBegin('double')) value = parseFloat(value)
+      else if (Odac.Var(this.types[col]).isBegin('float')) value = parseFloat(value)
+      else if (Odac.Var(this.types[col]).isBegin('boolean')) value = parseInt(value)
+      else if (Odac.Var(this.types[col]).isBegin('json')) value = JSON.parse(value)
     } else if (!(value instanceof Raw)) {
-      if (Candy.Var(this.types[col]).isBegin('tinyint(1)')) value = parseInt(value)
-      else if (Candy.Var(this.types[col]).isBegin('int')) value = parseInt(value)
-      else if (Candy.Var(this.types[col]).isBegin('double')) value = parseFloat(value)
-      else if (Candy.Var(this.types[col]).isBegin('float')) value = parseFloat(value)
-      else if (Candy.Var(this.types[col]).isBegin('boolean')) value = parseInt(value)
-      else if (Candy.Var(this.types[col]).isBegin('json')) value = JSON.stringify(value)
-      else if (Candy.Var(this.types[col]).isBegin('date', 'datetime', 'timestamp')) value = Candy.Var(value).date('Y-m-d H:i:s')
+      if (Odac.Var(this.types[col]).isBegin('tinyint(1)')) value = parseInt(value)
+      else if (Odac.Var(this.types[col]).isBegin('int')) value = parseInt(value)
+      else if (Odac.Var(this.types[col]).isBegin('double')) value = parseFloat(value)
+      else if (Odac.Var(this.types[col]).isBegin('float')) value = parseFloat(value)
+      else if (Odac.Var(this.types[col]).isBegin('boolean')) value = parseInt(value)
+      else if (Odac.Var(this.types[col]).isBegin('json')) value = JSON.stringify(value)
+      else if (Odac.Var(this.types[col]).isBegin('date', 'datetime', 'timestamp')) value = Odac.Var(value).date('Y-m-d H:i:s')
     }
     return value
   }
@@ -513,22 +513,22 @@ module.exports = {
   db: {},
   init: function () {
     return new Promise(resolve => {
-      if (!Candy.Config.database) return resolve(false)
-      let multiple = typeof Candy.Config.database[Object.keys(Candy.Config.database)[0]] === 'object'
-      let dbs = multiple ? Candy.Config.database : {default: Candy.Config.database}
+      if (!Odac.Config.database) return resolve(false)
+      let multiple = typeof Odac.Config.database[Object.keys(Odac.Config.database)[0]] === 'object'
+      let dbs = multiple ? Odac.Config.database : {default: Odac.Config.database}
       for (let key of Object.keys(dbs)) {
         let db = dbs[key]
         if (db.type && db.type != 'mysql') continue
-        Candy.Mysql.conn[key] = mysql.createConnection({
+        Odac.Mysql.conn[key] = mysql.createConnection({
           host: db.host ?? '127.0.0.1',
           user: db.user,
           password: db.password,
           database: db.database,
           stringifyObjects: true
         })
-        Candy.Mysql.conn[key].connect(err => {
+        Odac.Mysql.conn[key].connect(err => {
           if (err) {
-            console.error(`CandyPack Mysql Error: Failed to connect to database '${key}'`)
+            console.error(`Odac Mysql Error: Failed to connect to database '${key}'`)
             console.error(`Host: ${db.host ?? '127.0.0.1'}`)
             console.error(`User: ${db.user}`)
             console.error(`Database: ${db.database}`)
@@ -536,16 +536,16 @@ module.exports = {
             return resolve(false)
           }
         })
-        Candy.Mysql.conn[key].query('SHOW TABLES', (err, result) => {
+        Odac.Mysql.conn[key].query('SHOW TABLES', (err, result) => {
           if (err) {
-            console.error(`CandyPack Mysql Error: Failed to query tables from database '${key}'`)
+            console.error(`Odac Mysql Error: Failed to query tables from database '${key}'`)
             console.error(`Error: ${err.message}`)
             return resolve(false)
           }
           for (let table of result)
             for (let key of Object.keys(table)) {
               let t = () => {
-                new Mysql(table[key], Candy.Mysql.conn['default'])
+                new Mysql(table[key], Odac.Mysql.conn['default'])
               }
               t()
             }
@@ -555,16 +555,16 @@ module.exports = {
     })
   },
   database: function (name) {
-    if (!Candy.Mysql.conn[name]) return null
-    return new Mysql(name, Candy.Mysql.conn[name])
+    if (!Odac.Mysql.conn[name]) return null
+    return new Mysql(name, Odac.Mysql.conn[name])
   },
   run: function (query, params) {
-    if (!Candy.Mysql.conn['default']) return Promise.resolve(false)
-    return new Mysql(null, Candy.Mysql.conn['default']).run(query, params)
+    if (!Odac.Mysql.conn['default']) return Promise.resolve(false)
+    return new Mysql(null, Odac.Mysql.conn['default']).run(query, params)
   },
   table: function (name) {
-    if (!Candy.Mysql.conn['default']) return null
-    return new Mysql(name, Candy.Mysql.conn['default'])
+    if (!Odac.Mysql.conn['default']) return null
+    return new Mysql(name, Odac.Mysql.conn['default'])
   },
   raw: function (query) {
     if (typeof query !== 'string') {

package/src/Odac.js

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

package/{framework/src → src}/Request.js

@@ -1,12 +1,12 @@
 const nodeCrypto = require('crypto')
 
-class CandyRequest {
-  #candy
+class OdacRequest {
+  #odac
   #complete = false
   #cookies = {received: [], sent: []}
   data = {post: {}, get: {}, url: {}}
   #event = {data: [], end: []}
-  #headers = {Server: 'CandyPack'}
+  #headers = {Server: 'Odac'}
   #status = 200
   #timeout = null
   #earlyHints = null
@@ -16,30 +16,32 @@ class CandyRequest {
   clientSkeleton = null
   page = null
 
-  constructor(id, req, res, candy) {
+  constructor(id, req, res, odac) {
     this.id = id
     this.req = req
     this.res = res
-    this.#candy = candy
+    this.#odac = odac
     this.method = req.method.toLowerCase()
     this.url = req.url
     this.host = req.headers.host
-    this.ssl = this.header('x-candy-connection-ssl') === 'true'
-    this.ip = (this.header('x-candy-connection-remoteaddress') ?? req.connection.remoteAddress).replace('::ffff:', '')
-    delete this.req.headers['x-candy-connection-ssl']
-    delete this.req.headers['x-candy-connection-remoteaddress']
+    this.ssl = this.header('x-odac-connection-ssl') === 'true'
+    this.ip = (this.header('x-odac-connection-remoteaddress') ?? req.connection.remoteAddress).replace('::ffff:', '')
+    delete this.req.headers['x-odac-connection-ssl']
+    delete this.req.headers['x-odac-connection-remoteaddress']
     let route = req.headers.host.split('.')[0]
-    if (!Candy.Route.routes[route]) route = 'www'
+    if (!Odac.Route.routes[route]) route = 'www'
     this.route = route
-    this.#timeout = setTimeout(() => !this.res.finished && this.abort(408), Candy.Config.request.timeout)
+    if (this.res) {
+      this.#timeout = setTimeout(() => !this.res.finished && this.abort(408), Odac.Config.request.timeout)
+    }
     this.#data()
-    if (!Candy.Request) Candy.Request = {}
-    if (!this.cookie('candy_client') || !this.session('_client') || this.session('_client') !== this.cookie('candy_client')) {
+    if (!Odac.Request) Odac.Request = {}
+    if (!this.cookie('odac_client') || !this.session('_client') || this.session('_client') !== this.cookie('odac_client')) {
       let client = nodeCrypto
         .createHash('md5')
         .update(this.ip + this.id + Date.now().toString() + Math.random().toString())
         .digest('hex')
-      this.cookie('candy_client', client, {expires: null, httpOnly: false})
+      this.cookie('odac_client', client, {expires: null, httpOnly: false})
       this.session('_client', client)
     }
   }
@@ -48,8 +50,8 @@ class CandyRequest {
   async abort(code) {
     this.status(code)
     let result = {401: 'Unauthorized', 404: 'Not Found', 408: 'Request Timeout'}[code] ?? null
-    if (Candy.Route.routes[this.route].error && Candy.Route.routes[this.route].error[code])
-      result = await Candy.Route.routes[this.route].error[code].cache(this.#candy)
+    if (Odac.Route.routes[this.route].error && Odac.Route.routes[this.route].error[code])
+      result = await Odac.Route.routes[this.route].error[code].cache(this.#odac)
     this.end(result)
   }
 
@@ -179,8 +181,8 @@ class CandyRequest {
   print() {
     if (this.res.headersSent) return
 
-    if (this.#earlyHints && this.#earlyHints.length > 0 && global.Candy?.View?.EarlyHints) {
-      global.Candy.View.EarlyHints.send(this.res, this.#earlyHints)
+    if (this.#earlyHints && this.#earlyHints.length > 0 && global.Odac?.View?.EarlyHints) {
+      global.Odac.View.EarlyHints.send(this.res, this.#earlyHints)
     }
 
     this.#headers['Set-Cookie'] = this.#cookies.sent
@@ -225,8 +227,8 @@ class CandyRequest {
 
   // - SESSION
   session(key, value) {
-    if (!Candy.Request.session) Candy.Request.session = {}
-    if (!Candy.Request.sessionLocks) Candy.Request.sessionLocks = {}
+    if (!Odac.Request.session) Odac.Request.session = {}
+    if (!Odac.Request.sessionLocks) Odac.Request.sessionLocks = {}
 
     let pri = nodeCrypto
       .createHash('md5')
@@ -234,45 +236,45 @@ class CandyRequest {
       .digest('hex')
     let pub = this.cookie('candy_session')
 
-    if (!pub || !Candy.Request.session[pub + '-' + pri]) {
+    if (!pub || !Odac.Request.session[pub + '-' + pri]) {
       const lockKey = `${this.ip}-${pri}`
       const now = Date.now()
 
-      if (Candy.Request.sessionLocks[lockKey]) {
-        const lock = Candy.Request.sessionLocks[lockKey]
-        if (now - lock.timestamp < 5000 && Candy.Request.session[`${lock.sessionId}-${pri}`]) {
+      if (Odac.Request.sessionLocks[lockKey]) {
+        const lock = Odac.Request.sessionLocks[lockKey]
+        if (now - lock.timestamp < 5000 && Odac.Request.session[`${lock.sessionId}-${pri}`]) {
           pub = lock.sessionId
         } else {
-          delete Candy.Request.sessionLocks[lockKey]
+          delete Odac.Request.sessionLocks[lockKey]
         }
       }
 
       if (!pub) {
-        const sessionLockValues = Object.values(Candy.Request.sessionLocks)
+        const sessionLockValues = Object.values(Odac.Request.sessionLocks)
         const activeSessions = new Set(sessionLockValues.map(l => l.sessionId))
         do {
           pub = nodeCrypto
             .createHash('md5')
             .update(this.ip + this.id + Date.now().toString() + Math.random().toString())
             .digest('hex')
-        } while (Candy.Request.session[`${pub}-${pri}`] || activeSessions.has(pub))
+        } while (Odac.Request.session[`${pub}-${pri}`] || activeSessions.has(pub))
 
-        Candy.Request.sessionLocks[lockKey] = {sessionId: pub, timestamp: now}
-        Candy.Request.session[`${pub}-${pri}`] = {}
+        Odac.Request.sessionLocks[lockKey] = {sessionId: pub, timestamp: now}
+        Odac.Request.session[`${pub}-${pri}`] = {}
         this.cookie('candy_session', `${pub}`)
 
         setTimeout(() => {
-          if (Candy.Request.sessionLocks[lockKey]?.timestamp === now) {
-            delete Candy.Request.sessionLocks[lockKey]
+          if (Odac.Request.sessionLocks[lockKey]?.timestamp === now) {
+            delete Odac.Request.sessionLocks[lockKey]
           }
         }, 5000)
       }
     }
 
-    if (!Candy.Request.session[pub + '-' + pri]) Candy.Request.session[pub + '-' + pri] = {}
-    if (value === undefined) return Candy.Request.session[pub + '-' + pri][key] ?? null
-    else if (value === null) delete Candy.Request.session[pub + '-' + pri][key]
-    else Candy.Request.session[pub + '-' + pri][key] = value
+    if (!Odac.Request.session[pub + '-' + pri]) Odac.Request.session[pub + '-' + pri] = {}
+    if (value === undefined) return Odac.Request.session[pub + '-' + pri][key] ?? null
+    else if (value === null) delete Odac.Request.session[pub + '-' + pri][key]
+    else Odac.Request.session[pub + '-' + pri][key] = value
   }
 
   // - SET
@@ -298,4 +300,4 @@ class CandyRequest {
   }
 }
 
-module.exports = CandyRequest
+module.exports = OdacRequest