odac 1.0.1 → 1.2.0

package/src/Config.js

@@ -5,19 +5,24 @@ const os = require('os')
 module.exports = {
   auth: {
     key: 'id',
-    token: 'candy_auth'
+    token: 'odac_auth' // This is the TABLE NAME for tokens, not a secret token.
   },
   request: {
     timeout: 10000
   },
   encrypt: {
-    key: 'odac'
+    key: 'odac' // Default encryption key. MUST be overridden in production.
   },
   earlyHints: {
     enabled: true,
     auto: true,
     maxResources: 5
   },
+  ipc: {
+    driver: 'memory',
+    redis: 'default'
+  },
+  debug: process.env.NODE_ENV !== 'production',
 
   init: function () {
     try {
@@ -26,17 +31,17 @@ module.exports = {
       this.system = {}
     }
 
-    if (fs.existsSync(__dir + '/config.json')) {
+    if (fs.existsSync(__dir + '/odac.json')) {
       let config = {}
       try {
-        config = JSON.parse(fs.readFileSync(__dir + '/config.json'))
+        config = JSON.parse(fs.readFileSync(__dir + '/odac.json'))
         config = this._interpolate(config)
       } catch (err) {
-        console.error('Error reading config file:', __dir + '/config.json', err.message)
+        console.error('Error reading config file:', __dir + '/odac.json', err.message)
       }
       this._deepMerge(this, config)
     }
-    this.encrypt.key = nodeCrypto.createHash('md5').update(this.encrypt.key).digest('hex')
+    this.encrypt.key = nodeCrypto.createHash('sha256').update(this.encrypt.key).digest()
   },
 
   _interpolate: function (obj) {
@@ -44,7 +49,7 @@ module.exports = {
       return obj.replace(/\$\{(\w+)\}/g, (_, key) => {
         // Special variables
         if (key === 'odac') {
-          return __dirname.replace(/\/framework\/src$/, '')
+          return __dirname.replace(/\/src$/, '/client')
         }
         // Environment variables
         return process.env[key] || ''

package/src/Database.js

@@ -0,0 +1,188 @@
+'use strict'
+const knex = require('knex')
+
+class DatabaseManager {
+  constructor() {
+    this.connections = {}
+  }
+
+  async init() {
+    if (!Odac.Config.database) return
+
+    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]
+      let client = 'mysql2'
+      if (db.type === 'postgres' || db.type === 'pg' || db.type === 'postgresql') client = 'pg'
+      if (db.type === 'sqlite' || db.type === 'sqlite3') client = 'sqlite3'
+
+      let connectionConfig = {}
+
+      if (client === 'sqlite3') {
+        connectionConfig = {
+          filename: db.filename || db.database || './dev.sqlite3'
+        }
+      } else {
+        connectionConfig = {
+          host: db.host || '127.0.0.1',
+          user: db.user,
+          password: db.password,
+          database: db.database,
+          port: db.port
+        }
+      }
+
+      this.connections[key] = knex({
+        client: client,
+        connection: connectionConfig,
+        pool: {
+          min: 0,
+          max: db.connectionLimit || 10
+        },
+        useNullAsDefault: true // For sqlite
+      })
+
+      // Test connection
+      try {
+        await this.connections[key].raw('SELECT 1')
+      } catch (e) {
+        console.error(`Odac Database Error: Failed to connect to '${key}' database.`)
+        console.error(e.message)
+      }
+    }
+  }
+
+  nanoid(size = 21) {
+    const nodeCrypto = require('crypto')
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+    let id = ''
+    while (id.length < size) {
+      const bytes = nodeCrypto.randomBytes(size + 5)
+      for (let i = 0; i < bytes.length; i++) {
+        const byte = bytes[i] & 63
+        if (byte < 62) {
+          id += alphabet[byte]
+          if (id.length === size) break
+        }
+      }
+    }
+    return id
+  }
+}
+
+const manager = new DatabaseManager()
+
+const tableProxyHandler = {
+  get(knexInstance, prop) {
+    // 1. Check for legacy/alias methods
+    if (prop === 'run') return knexInstance.raw.bind(knexInstance)
+    if (prop === 'table')
+      return function (tableName) {
+        return knexInstance(tableName)
+      }
+
+    // 2. Pass through Knex instance methods (raw, schema, fn, destroy, etc.)
+    if (typeof knexInstance[prop] === 'function') {
+      return knexInstance[prop].bind(knexInstance)
+    }
+    if (prop in knexInstance) {
+      return knexInstance[prop]
+    }
+
+    // 3. Assume it's a table name and return a Query Builder
+    // But we need to be careful not to intercept Promise methods if they are accessed on the instance (though knex instance isn't a promise)
+
+    // Create the Query Builder
+    const qb = knexInstance(prop)
+
+    // Odac DX Improvement: Wrap count() to return a clean number
+    const originalCount = qb.count
+    qb.count = function (...args) {
+      this._odacIsCount = true
+      return originalCount.apply(this, args)
+    }
+
+    const originalThen = qb.then
+    qb.then = function (resolve, reject) {
+      if (this._odacIsCount) {
+        return originalThen.call(
+          this,
+          result => {
+            // If the result is a single row with a single key, treat it as a scalar count usually
+            const isScalar = Array.isArray(result) && result.length === 1 && Object.keys(result[0]).length === 1
+
+            if (isScalar) {
+              const keys = Object.keys(result[0])
+              if (keys.length === 1) {
+                const val = result[0][keys[0]]
+                // Parse string numbers (common in Postgres for count)
+                if (val != null && String(val).trim() !== '' && !isNaN(val)) {
+                  resolve(Number(val))
+                  return
+                }
+              }
+            }
+            resolve(result)
+          },
+          reject
+        )
+      }
+      return originalThen.call(this, resolve, reject)
+    }
+
+    // 4. Extend the Query Builder with ODAC specific methods
+
+    // .schema(callback) for "Code-First" migrations
+    // Usage: await Odac.DB.users.schema(t => { t.string('name') })
+    qb.schema = async function (callback) {
+      const exists = await knexInstance.schema.hasTable(prop)
+      if (!exists) {
+        await knexInstance.schema.createTable(prop, callback)
+      }
+      return this
+    }
+
+    return qb
+  }
+}
+
+const rootProxy = new Proxy(manager, {
+  get(target, prop) {
+    // Access to internal manager methods
+    if (prop === 'init') return target.init.bind(target)
+    if (prop === 'connections') return target.connections
+
+    // Access to specific database connection: Odac.DB.analytics
+    if (target.connections[prop]) {
+      return new Proxy(target.connections[prop], tableProxyHandler)
+    }
+
+    // Direct access to raw/fn/schema/table on default connection
+    if (target.connections['default'] && (prop === 'raw' || prop === 'fn' || prop === 'schema' || prop === 'table')) {
+      if (prop === 'table')
+        return function (tableName) {
+          return target.connections['default'](tableName)
+        }
+
+      const val = target.connections['default'][prop]
+      if (typeof val === 'function') {
+        return val.bind(target.connections['default'])
+      }
+      return val
+    }
+
+    // Expose nanoid helper directly on Odac.DB.nanoid()
+    if (prop === 'nanoid') return target.nanoid.bind(target)
+
+    // Default connection fallback: Odac.DB.users -> default.users
+    if (target.connections['default']) {
+      return tableProxyHandler.get(target.connections['default'], prop)
+    }
+
+    return undefined
+  }
+})
+
+module.exports = rootProxy

package/src/Env.js

@@ -20,7 +20,9 @@ module.exports = {
         // Parse quoted values
         value = this._parseValue(value)
 
-        process.env[key] = value
+        if (process.env[key] === undefined) {
+          process.env[key] = value
+        }
       })
     } catch (err) {
       console.error('Error reading .env file:', err.message)

package/src/Ipc.js

@@ -0,0 +1,337 @@
+const cluster = require('node:cluster')
+const {EventEmitter} = require('node:events')
+
+class Ipc extends EventEmitter {
+  constructor() {
+    super()
+    this.driver = null
+    this.config = {}
+    this._requests = new Map() // For memory driver response tracking
+    this._subs = new Map() // For memory driver subscriptions
+  }
+
+  /**
+   * ARCHITECTURE NOTE:
+   * This module implements a "Primary-Replica" pattern for the 'memory' driver.
+   * - The Primary process holds the 'Source of Truth' in local Maps.
+   * - Workers communicate via IPC (process.send) to read/write to this central store.
+   * This ensures state consistency across the cluster without needing Redis.
+   */
+  async init() {
+    if (this.initialized) return
+    this.initialized = true
+
+    this.config = Odac.Config.ipc || {driver: 'memory'}
+
+    // default MaxListeners is 10. If we have thousands of different channels, it's fine.
+    // But if we attach many listeners to the "same" channel or event emitter, we might need more.
+    // For Ipc (which extends EventEmitter), let's bump it up just in case.
+    this.setMaxListeners(0) // Unlimited
+
+    if (this.config.driver === 'redis') {
+      await this._initRedis()
+    } else {
+      await this._initMemory()
+    }
+  }
+
+  // --- Public API ---
+
+  async set(key, value, ttl = 0) {
+    if (this.config.driver === 'redis') {
+      const args = [key, JSON.stringify(value)]
+      if (ttl > 0) args.push('EX', ttl)
+      return this.redis.set(...args)
+    } else {
+      return this._sendMemory('set', {key, value, ttl})
+    }
+  }
+
+  async get(key) {
+    if (this.config.driver === 'redis') {
+      const val = await this.redis.get(key)
+      return val ? JSON.parse(val) : null
+    } else {
+      return this._sendMemory('get', {key})
+    }
+  }
+
+  async del(key) {
+    if (this.config.driver === 'redis') {
+      return this.redis.del(key)
+    } else {
+      return this._sendMemory('del', {key})
+    }
+  }
+
+  async publish(channel, message) {
+    if (this.config.driver === 'redis') {
+      return this.redis.publish(channel, JSON.stringify(message))
+    } else {
+      return this._sendMemory('publish', {channel, message})
+    }
+  }
+
+  async subscribe(channel, callback) {
+    if (this.config.driver === 'redis') {
+      if (!this.subRedis) {
+        this.subRedis = this.redis.duplicate()
+        await this.subRedis.connect()
+        this.subRedis.on('message', (chan, msg) => {
+          this.emit(chan, JSON.parse(msg))
+        })
+      }
+      // Redis handles duplicate subscriptions gracefully (ignores them)
+      await this.subRedis.subscribe(channel)
+      this.on(channel, callback)
+    } else {
+      // Memory driver subscription
+      if (!this._subs.has(channel)) {
+        this._subs.set(channel, new Set())
+        // Inform main process that this worker is subscribed
+        this._sendMemory('subscribe', {channel})
+      }
+      this._subs.get(channel).add(callback)
+    }
+  }
+
+  async unsubscribe(channel, callback) {
+    if (this.config.driver === 'redis') {
+      this.removeListener(channel, callback)
+      // If no more listeners for this channel, unsubscribe from redis to save resources
+      if (this.listenerCount(channel) === 0 && this.subRedis) {
+        await this.subRedis.unsubscribe(channel)
+      }
+    } else {
+      if (this._subs.has(channel)) {
+        const callbacks = this._subs.get(channel)
+        callbacks.delete(callback)
+        if (callbacks.size === 0) {
+          this._subs.delete(channel)
+          this._sendMemory('unsubscribe', {channel})
+        }
+      }
+    }
+  }
+
+  // --- Drivers ---
+
+  async _initRedis() {
+    try {
+      const Redis = require('redis')
+      this.redis = Redis.createClient(Odac.Config.database?.redis?.[this.config.redis || 'default'] || {})
+      await this.redis.connect()
+    } catch (e) {
+      console.error('IPC Redis Driver Error:', e)
+      // Re-throw to ensure application doesn't start in a broken state.
+      throw e
+    }
+  }
+
+  async _initMemory() {
+    if (cluster.isPrimary) {
+      if (!this._memoryStore) this._memoryStore = new Map()
+      if (!this._memorySubs) this._memorySubs = new Map()
+
+      // PREVENT DUPLICATE LISTENERS via Global References
+      // If Ipc is reloaded (hot-reload), the old listener remains on 'cluster' (global).
+      // We must remove it before adding a new one.
+
+      if (global.__odac_ipc_message_handler) {
+        cluster.removeListener('message', global.__odac_ipc_message_handler)
+      }
+      if (global.__odac_ipc_exit_handler) {
+        cluster.removeListener('exit', global.__odac_ipc_exit_handler)
+      }
+
+      const messageHandler = (worker, msg) => {
+        if (msg && msg.type && msg.type.startsWith('ipc:')) {
+          this._handlePrimaryMessage(worker, msg)
+        }
+      }
+
+      const exitHandler = worker => {
+        // Cleanup worker subscriptions on exit
+        for (const [channel, workers] of this._memorySubs) {
+          workers.delete(worker.id)
+          if (workers.size === 0) {
+            this._memorySubs.delete(channel)
+          }
+        }
+      }
+
+      // Save references globally
+      global.__odac_ipc_message_handler = messageHandler
+      global.__odac_ipc_exit_handler = exitHandler
+
+      cluster.on('message', messageHandler)
+      cluster.on('exit', exitHandler)
+
+      this._startGarbageCollector()
+    } else {
+      process.on('message', msg => {
+        if (msg && msg.type === 'ipc:response') {
+          const req = this._requests.get(msg.id)
+          // If request exists (hasn't timed out yet)
+          if (req) {
+            clearTimeout(req.timeout) // Stop the timeout timer
+            req.resolve(msg.data)
+            this._requests.delete(msg.id)
+          }
+        } else if (msg && msg.type === 'ipc:message') {
+          // Pub/Sub message received from Primary
+          const subs = this._subs.get(msg.channel)
+          if (subs) {
+            subs.forEach(cb => cb(msg.message))
+          }
+        }
+      })
+    }
+  }
+
+  _sendMemory(action, payload) {
+    if (cluster.isPrimary) {
+      // If used from primary directly (rare but possible)
+      // Logic would be direct call to _handlePrimaryMessage logic essentially,
+      // but simpler. For now, assuming IPC is mostly used by workers.
+      // If primary uses it, we should implement direct store access.
+      return this._handleDirectPrimaryCall(action, payload)
+    }
+
+    return new Promise((resolve, reject) => {
+      const id = require('node:crypto').randomUUID()
+      if (action !== 'subscribe' && action !== 'publish' && action !== 'unsubscribe') {
+        // Only wait for response for data ops
+        const timeout = setTimeout(() => {
+          if (this._requests.has(id)) {
+            this._requests.delete(id)
+            reject(new Error(`IPC request timed out: ${action}`))
+          }
+        }, 5000)
+
+        this._requests.set(id, {resolve, reject, timeout})
+      } else {
+        resolve() // Pub/Sub/Unsub doesn't wait for ack
+      }
+      process.send({type: `ipc:${action}`, id, ...payload})
+    })
+  }
+
+  _handleDirectPrimaryCall(action, payload) {
+    // Basic implementation for Primary process using itself
+    if (action === 'set') {
+      const expireAt = payload.ttl > 0 ? Date.now() + payload.ttl * 1000 : Infinity
+      this._memoryStore.set(payload.key, {value: payload.value, expireAt})
+      return true
+    }
+    if (action === 'get') {
+      const data = this._memoryStore.get(payload.key)
+      if (!data) return null
+      if (data.expireAt !== Infinity && Date.now() > data.expireAt) {
+        this._memoryStore.delete(payload.key)
+        return null
+      }
+      return data.value
+    }
+    if (action === 'del') return this._memoryStore.delete(payload.key)
+    if (action === 'publish') {
+      const workers = this._memorySubs.get(payload.channel)
+      if (workers) {
+        workers.forEach(wId => {
+          const w = cluster.workers[wId]
+          if (w) w.send({type: 'ipc:message', channel: payload.channel, message: payload.message})
+        })
+      }
+    }
+    // subscribe on primary not deeply implemented to avoid complexity, usually workers listen.
+  }
+
+  _startGarbageCollector() {
+    // Run every 5 minutes.
+    // This is "lazy enough" not to impact CPU, but frequent enough to free memory.
+    const interval = setInterval(
+      () => {
+        try {
+          const now = Date.now()
+          for (const [key, data] of this._memoryStore) {
+            if (data.expireAt !== Infinity && now > data.expireAt) {
+              this._memoryStore.delete(key)
+            }
+          }
+        } catch (e) {
+          console.error('[Odac IPC GC Error]', e)
+        }
+      },
+      5 * 60 * 1000
+    )
+
+    // Allow process to exit even if this interval is running
+    interval.unref()
+  }
+
+  _handlePrimaryMessage(worker, msg) {
+    const {type, id, key, value, ttl, channel, message} = msg
+    const action = type.replace('ipc:', '')
+
+    let response = null
+
+    switch (action) {
+      case 'set': {
+        const expireAt = ttl > 0 ? Date.now() + ttl * 1000 : Infinity
+        this._memoryStore.set(key, {value, expireAt})
+        response = true
+        break
+      }
+      case 'get': {
+        const data = this._memoryStore.get(key)
+        if (data) {
+          if (data.expireAt !== Infinity && Date.now() > data.expireAt) {
+            this._memoryStore.delete(key)
+            response = null
+          } else {
+            response = data.value
+          }
+        } else {
+          response = null
+        }
+        break
+      }
+      case 'del':
+        response = this._memoryStore.delete(key)
+        break
+      case 'subscribe':
+        if (!this._memorySubs.has(channel)) {
+          this._memorySubs.set(channel, new Set())
+        }
+        this._memorySubs.get(channel).add(worker.id)
+        break
+      case 'unsubscribe':
+        if (this._memorySubs.has(channel)) {
+          this._memorySubs.get(channel).delete(worker.id)
+          if (this._memorySubs.get(channel).size === 0) {
+            this._memorySubs.delete(channel)
+          }
+        }
+        break
+      case 'publish': {
+        // Relay to all subscribed workers
+        const workers = this._memorySubs.get(channel)
+        if (workers) {
+          workers.forEach(wId => {
+            // Don't echo back to sender if desired? Usually pub/sub receives own too if subbed.
+            // Redis publishes to all subscribers.
+            const w = cluster.workers[wId]
+            if (w) w.send({type: 'ipc:message', channel, message})
+          })
+        }
+        break
+      }
+    }
+
+    if (id) {
+      worker.send({type: 'ipc:response', id, data: response})
+    }
+  }
+}
+
+module.exports = new Ipc()

package/src/Lang.js

@@ -43,9 +43,16 @@ class Lang {
 
   set(lang) {
     if (!lang || lang.length !== 2 || !this.#odac.Var(lang).is('alpha')) {
-      if (this.#odac.Request.header('ACCEPT-LANGUAGE') && this.#odac.Request.header('ACCEPT-LANGUAGE').length > 1)
+      if (
+        this.#odac.Request &&
+        this.#odac.Request.header &&
+        this.#odac.Request.header('ACCEPT-LANGUAGE') &&
+        this.#odac.Request.header('ACCEPT-LANGUAGE').length > 1
+      ) {
         lang = this.#odac.Request.header('ACCEPT-LANGUAGE').substr(0, 2)
-      else lang = this.#odac.Config.lang?.default || 'en'
+      } else {
+        lang = this.#odac.Config.lang?.default || 'en'
+      }
     }
     this.#lang = lang
     if (fs.existsSync(__dir + '/storage/language/' + lang + '.json'))