bajo 2.18.0 → 2.20.0

package/test/cache.test.js

@@ -0,0 +1,94 @@
+/* global describe, it, beforeEach, afterEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+import fastGlob from 'fast-glob'
+import lodash from 'lodash'
+
+import Cache from '../class/cache.js'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-cache-test-'))
+
+describe('Cache', () => {
+  let root
+  let app
+  let cache
+
+  beforeEach(() => {
+    root = createTempRoot()
+    app = {
+      getPluginDataDir: () => path.join(root, 'bajo'),
+      bajo: {
+        breakNsPath: (name) => {
+          const [nsPart, p] = name.split(':')
+          const [ns, subNs] = nsPart.split('.')
+          return { ns, subNs, path: p }
+        }
+      },
+      lib: {
+        aneka: {
+          parseDuration: (v) => typeof v === 'number' ? v : 0
+        },
+        fs,
+        fastGlob,
+        _: lodash
+      }
+    }
+    cache = new Cache(app)
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('prepares cache location only for namespaced key and non-zero ttl', () => {
+    expect(cache.prep('main:path', 0)).to.equal(undefined)
+    expect(cache.prep('main:path', 1000)).to.equal(undefined)
+
+    const prep = cache.prep('main.api:path/to/item', 1000)
+    expect(prep.file).to.include('/main/api/1000/path/to/item')
+    expect(fs.existsSync(prep.dir)).to.equal(true)
+  })
+
+  it('saves and loads json/object content', async () => {
+    await cache.save('main.api:item', { a: 1 }, 1000)
+    const item = await cache.load('main.api:item', 1000)
+
+    expect(item).to.deep.equal({ a: 1 })
+  })
+
+  it('returns undefined for expired cache and removes ttl directory', async () => {
+    await cache.save('main.api:item', 'ok', 1)
+    const { dir } = cache.prep('main.api:item', 1)
+    const old = Date.now() - 5000
+    fs.utimesSync(dir, old / 1000, old / 1000)
+
+    const result = await cache.load('main.api:item', 1)
+
+    expect(result).to.equal(undefined)
+    expect(fs.existsSync(dir)).to.equal(false)
+  })
+
+  it('purges by name and wildcard', () => {
+    const a = cache.prep('main.api:a', 1000)
+    const b = cache.prep('main.web:b', 1000)
+    fs.writeFileSync(a.file, 'a', 'utf8')
+    fs.writeFileSync(b.file, 'b', 'utf8')
+
+    cache.purge('main')
+    expect(fs.existsSync(cache.getRootDir() + '/main')).to.equal(false)
+
+    const c = cache.prep('other.api:c', 1000)
+    fs.writeFileSync(c.file, 'c', 'utf8')
+    cache._purgeItem('*')
+    expect(fs.existsSync(cache.getRootDir() + '/other')).to.equal(false)
+  })
+
+  it('disposes app reference', async () => {
+    await cache.dispose()
+
+    expect(cache.app).to.equal(null)
+  })
+})

package/test/e2e.test.js

@@ -0,0 +1,137 @@
+/* global describe, it, beforeEach, afterEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { pathToFileURL } from 'node:url'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-e2e-test-'))
+
+const runNode = (cwd, file, timeoutMs = 8000) => {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [file], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString()
+    })
+    child.stderr.on('data', chunk => {
+      stderr += chunk.toString()
+    })
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM')
+      resolve({ code: null, stdout, stderr, timedOut: true })
+    }, timeoutMs)
+    child.on('close', code => {
+      clearTimeout(timer)
+      resolve({ code, stdout, stderr, timedOut: false })
+    })
+  })
+}
+
+describe('E2E', () => {
+  let rootDir
+
+  beforeEach(() => {
+    rootDir = createTempRoot()
+  })
+
+  afterEach(() => {
+    if (rootDir) fs.rmSync(rootDir, { recursive: true, force: true })
+  })
+
+  it('boots a real app in a separate process and runs a real plugin end to end', async function () {
+    this.timeout(12000)
+    const packageEntry = pathToFileURL(path.join('/mnt/d/Projects/Bajo/bajo', 'index.js')).href
+    const pluginName = 'demo-e2e-plugin'
+    const pluginDir = path.join(rootDir, 'node_modules', pluginName)
+    const appMainDir = path.join(rootDir, 'main')
+    const outputFile = path.join(rootDir, 'e2e-output.txt')
+
+    await fs.ensureDir(pluginDir)
+    await fs.ensureDir(appMainDir)
+
+    await fs.writeJson(path.join(rootDir, 'package.json'), {
+      name: 'bajo-e2e-app',
+      type: 'module',
+      bajo: {
+        plugins: [pluginName]
+      }
+    })
+
+    await fs.writeJson(path.join(pluginDir, 'package.json'), {
+      name: pluginName,
+      version: '1.0.0',
+      type: 'module',
+      main: 'index.js'
+    })
+
+    await fs.writeFile(path.join(pluginDir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+
+  return class E2ePlugin extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = {}
+      this.start = async () => {
+        await this.app.lib.fs.writeFile(this.app.dir + '/e2e-output.txt', 'started:' + this.ns, 'utf8')
+      }
+    }
+  }
+}
+
+export default factory
+`, 'utf8')
+
+    await fs.writeFile(path.join(appMainDir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+
+  return class Main extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = {}
+      this.start = async () => {
+        console.log('MAIN_STARTED')
+      }
+    }
+  }
+}
+
+export default factory
+`, 'utf8')
+
+    await fs.ensureDir(path.join(rootDir, 'data', 'config'))
+    await fs.writeJson(path.join(rootDir, 'data', 'config', 'bajo.json'), {
+      log: { level: 'silent', save: false },
+      exitHandler: false,
+      cache: { purgeIntvDur: '1h' }
+    })
+
+    await fs.writeFile(path.join(rootDir, 'run-app.js'), `
+import boot from ${JSON.stringify(packageEntry)}
+
+const app = await boot({ cwd: process.cwd() })
+console.log('BOOT_OK:' + !!app.getPlugin(${JSON.stringify(pluginName)}, true))
+process.exit(0)
+`, 'utf8')
+
+    const result = await runNode(rootDir, 'run-app.js')
+
+    expect(result.timedOut).to.equal(false)
+    expect(result.code).to.equal(0)
+    expect(result.stderr).to.equal('')
+    expect(result.stdout).to.include('MAIN_STARTED')
+    expect(result.stdout).to.include('BOOT_OK:true')
+    expect(fs.existsSync(outputFile)).to.equal(true)
+    expect(fs.readFileSync(outputFile, 'utf8')).to.match(/^started:/)
+  })
+})

package/test/err.test.js

@@ -0,0 +1,73 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+import lodash from 'lodash'
+
+import Err from '../class/err.js'
+
+describe('Err', () => {
+  const makePlugin = () => ({
+    ns: 'myPlugin',
+    app: {
+      lib: {
+        _: lodash,
+        aneka: { without: (arr) => arr.filter(Boolean) }
+      },
+      exit: () => {}
+    },
+    t: (msg, ctx) => {
+      if (msg === 'error') return 'Error'
+      if (msg === 'fieldError%s%s') return `${ctx}`
+      return msg
+    }
+  })
+
+  it('writes error object with payload and metadata', () => {
+    const plugin = makePlugin()
+    const err = new Err(plugin, 'hello %s', 'x', { code: 'E1', foo: 'bar' }).write()
+
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.equal('hello %s')
+    expect(err.code).to.equal('E1')
+    expect(err.foo).to.equal('bar')
+    expect(err.ns).to.equal('myPlugin')
+    expect(err.orgMessage).to.equal('hello %s')
+  })
+
+  it('formats details payload into detailsMessage', () => {
+    const plugin = makePlugin()
+    plugin.t = (msg) => {
+      if (msg === 'error') return 'Error'
+      if (msg === 'fieldError%s%s') return 'field-error'
+      if (msg.startsWith('validation.')) return 'invalid value'
+      return msg
+    }
+    const item = {
+      type: 'string.base',
+      message: '~invalid value',
+      context: { key: 'name', value: 1 }
+    }
+    const err = new Err(plugin, 'bad', { details: [item] }).write()
+
+    expect(err).to.have.property('detailsMessage').that.includes('Error:')
+    expect(err.details[0]).to.include({ field: 'name', error: 'invalid value', value: 1 })
+  })
+
+  it('prints and exits on fatal', () => {
+    const plugin = makePlugin()
+    let exitArg
+    plugin.app.exit = (arg) => { exitArg = arg }
+    const originalError = console.error
+    let called = false
+    console.error = () => { called = true }
+
+    try {
+      new Err(plugin, 'boom').fatal()
+    } finally {
+      console.error = originalError
+    }
+
+    expect(called).to.equal(true)
+    expect(exitArg).to.equal(true)
+  })
+})

package/test/helper.test.js

@@ -0,0 +1,39 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+
+import { outmatchNs, parseObject, lib } from '../class/_helper.js'
+
+describe('_helper', () => {
+  it('matches namespace/path patterns', () => {
+    const ctx = {
+      bajo: {
+        breakNsPath: (pattern) => {
+          const [fullNs, p] = pattern.split(':')
+          return { fullNs, path: p }
+        }
+      }
+    }
+
+    expect(outmatchNs.call(ctx, 'demo.api:users/12', 'demo.api:users/*')).to.equal(true)
+    expect(outmatchNs.call(ctx, 'demo.api', 'demo.api')).to.equal(true)
+    expect(outmatchNs.call(ctx, 'demo.api:users/12', 'x.api:users/*')).to.equal(false)
+  })
+
+  it('parses object and applies translator from namespace', () => {
+    const ctx = {
+      bajo: {
+        t: (text, arg) => `T:${text}:${arg}`
+      }
+    }
+    const parsed = parseObject.call(ctx, { msg: 't:hello|world' }, { ns: 'bajo', lang: 'en-US', parseValue: true })
+
+    expect(parsed).to.deep.equal({ msg: 'T:hello:world' })
+  })
+
+  it('exports library helpers', () => {
+    expect(lib).to.have.property('_')
+    expect(lib).to.have.property('fs')
+    expect(lib).to.have.property('dayjs')
+  })
+})

package/test/import-module.test.js

@@ -0,0 +1,138 @@
+/* global describe, it, beforeEach, afterEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+
+import importModule from '../lib/import-module.js'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-import-module-test-'))
+
+const writeModule = async (filePath, content) => {
+  await fs.ensureDir(path.dirname(filePath))
+  await fs.writeFile(filePath, content, 'utf8')
+}
+
+describe('importModule', () => {
+  let rootDir
+
+  beforeEach(() => {
+    rootDir = createTempRoot()
+  })
+
+  afterEach(() => {
+    delete globalThis.__importModuleCounter
+    if (rootDir) fs.rmSync(rootDir, { recursive: true, force: true })
+  })
+
+  it('imports default export by default', async () => {
+    const file = path.join(rootDir, 'default.js')
+    await writeModule(file, 'export default "hello"')
+
+    const mod = await importModule(file)
+
+    expect(mod).to.equal('hello')
+  })
+
+  it('returns module namespace when asDefaultImport is false', async () => {
+    const file = path.join(rootDir, 'named.js')
+    await writeModule(file, 'export const answer = 42; export default "x"')
+
+    const mod = await importModule(file, { asDefaultImport: false })
+
+    expect(mod).to.have.property('default', 'x')
+    expect(mod).to.have.property('answer', 42)
+  })
+
+  it('returns undefined when target file does not exist', async () => {
+    const mod = await importModule(path.join(rootDir, 'missing.js'))
+
+    expect(mod).to.equal(undefined)
+  })
+
+  it('imports a fresh copy when noCache is true', async () => {
+    const file = path.join(rootDir, 'counter.js')
+    await writeModule(file, 'globalThis.__importModuleCounter = (globalThis.__importModuleCounter ?? 0) + 1; export default globalThis.__importModuleCounter')
+
+    const first = await importModule(file, { noCache: true })
+    const second = await importModule(file, { noCache: true })
+
+    expect(first).to.equal(1)
+    expect(second).to.equal(2)
+  })
+
+  it('resolves plugin file through context when called with this', async () => {
+    const file = path.join(rootDir, 'ctx.js')
+    await writeModule(file, 'export default "from-context"')
+    const ctx = {
+      app: {
+        getPluginFile: (input) => {
+          expect(input).to.equal('plugin:file')
+          return file
+        }
+      }
+    }
+
+    const mod = await importModule.call(ctx, 'plugin:file')
+
+    expect(mod).to.equal('from-context')
+  })
+
+  it('wraps function modules into handler object when asHandler is true', async () => {
+    const file = path.join(rootDir, 'handler-fn.js')
+    await writeModule(file, 'export default function sampleHandler () { return "ok" }')
+
+    const mod = await importModule(file, { asHandler: true })
+
+    expect(mod).to.have.property('level', 999)
+    expect(mod).to.have.property('handler').that.is.a('function')
+    expect(mod.handler()).to.equal('ok')
+  })
+
+  it('returns plain object modules as-is in handler mode', async () => {
+    const file = path.join(rootDir, 'handler-obj.js')
+    await writeModule(file, 'export default { level: 100, handler: () => "ok" }')
+
+    const mod = await importModule(file, { asHandler: true })
+
+    expect(mod).to.have.property('level', 100)
+    expect(mod).to.have.property('handler').that.is.a('function')
+  })
+
+  it('throws a generic error for non-handler modules without context', async () => {
+    const file = path.join(rootDir, 'bad-handler.js')
+    await writeModule(file, 'export default 123')
+
+    let err
+    try {
+      await importModule(file, { asHandler: true })
+    } catch (error) {
+      err = error
+    }
+
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.equal(`File '${file}' is NOT a handler module`)
+  })
+
+  it('throws contextual error for non-handler modules with context', async () => {
+    const file = path.join(rootDir, 'bad-handler-ctx.js')
+    await writeModule(file, 'export default 123')
+    const ctx = {
+      app: {
+        getPluginFile: () => file
+      },
+      error: (code, target) => new Error(`${code}:${target}`)
+    }
+
+    let err
+    try {
+      await importModule.call(ctx, 'any:file', { asHandler: true })
+    } catch (error) {
+      err = error
+    }
+
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.equal(`fileNotModuleHandler%s:${file}`)
+  })
+})

package/test/integration.test.js

@@ -0,0 +1,218 @@
+/* global describe, it, beforeEach, afterEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+
+import App from '../class/app.js'
+import Bajo from '../class/bajo.js'
+import Base from '../class/base.js'
+import Plugin from '../class/plugin.js'
+import Log from '../class/log.js'
+import boot from '../index.js'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-integration-test-'))
+
+const cleanupNewProcessListeners = (beforeCounts) => {
+  const events = Object.keys(beforeCounts)
+  for (const event of events) {
+    const listeners = process.listeners(event)
+    const keep = beforeCounts[event]
+    if (listeners.length <= keep) continue
+    for (const listener of listeners.slice(keep)) {
+      process.removeListener(event, listener)
+    }
+  }
+}
+
+describe('Integration', () => {
+  let rootDir
+
+  beforeEach(async () => {
+    rootDir = createTempRoot()
+    await fs.writeJson(path.join(rootDir, 'package.json'), {
+      name: 'bajo-integration-app',
+      type: 'module'
+    })
+  })
+
+  afterEach(() => {
+    if (rootDir) fs.rmSync(rootDir, { recursive: true, force: true })
+  })
+
+  it('integrates App + Bajo + Plugin with real package info and ns-path file resolution', async () => {
+    const app = new App({ cwd: rootDir })
+    const bajo = new Bajo(app)
+    app.bajo = bajo
+    bajo.dir = {
+      base: rootDir,
+      data: path.join(rootDir, 'data')
+    }
+    await fs.ensureDir(bajo.dir.data)
+
+    const pluginDir = path.join(rootDir, 'plugins', 'demo-plugin')
+    await fs.ensureDir(pluginDir)
+    await fs.writeJson(path.join(pluginDir, 'package.json'), {
+      name: 'demo-plugin',
+      version: '1.0.0',
+      description: 'integration plugin'
+    })
+
+    const plugin = new Plugin('demo-plugin', app)
+    plugin.dir = { pkg: pluginDir }
+    app.addPlugin(plugin)
+    app.pluginPkgs = ['demo-plugin']
+
+    expect(plugin.getPkgInfo()).to.deep.equal({
+      name: 'demo-plugin',
+      version: '1.0.0',
+      description: 'integration plugin'
+    })
+
+    const dataDir = app.getPluginDataDir('demoPlugin')
+    expect(fs.existsSync(dataDir)).to.equal(true)
+
+    const resolved = app.getPluginFile('demoPlugin:/src/index.js')
+    expect(resolved).to.equal(path.join(pluginDir, 'src/index.js'))
+  })
+
+  it('integrates Base.loadConfig with real config files', async () => {
+    const app = new App({ cwd: rootDir })
+    const bajo = new Bajo(app)
+    app.bajo = bajo
+    app.pluginPkgs = ['main']
+
+    bajo.dir = {
+      base: rootDir,
+      data: path.join(rootDir, 'data')
+    }
+    bajo.config = { env: 'dev' }
+    await fs.ensureDir(path.join(bajo.dir.data, 'config'))
+    bajo.config.log = {
+      level: 'silent',
+      save: false,
+      pretty: false,
+      useUtc: false,
+      timeTaken: false,
+      dateFormat: 'YYYY-MM-DD',
+      rotation: { cycle: 'none', byPlugin: false }
+    }
+    app.log = new Log(app)
+    await fs.writeJson(path.join(bajo.dir.data, 'config', 'main.json'), {
+      title: 'Integration Main',
+      main: {
+        feature: true,
+        port: 7000
+      }
+    })
+
+    const main = new Base('main', app)
+    main.config = {
+      main: {
+        feature: false,
+        port: 3000
+      }
+    }
+    app.addPlugin(main)
+
+    await main.loadConfig()
+
+    expect(main.getConfig('main.feature')).to.equal(true)
+    expect(main.getConfig('main.port')).to.equal(7000)
+    expect(main.getConfig('title')).to.equal('Integration Main')
+    expect(main.dir.pkg).to.equal(path.join(rootDir, 'main'))
+    expect(main.dir.data).to.equal(path.join(bajo.dir.data, 'plugins', 'main'))
+  })
+
+  it('integrates App cache save/load using Bajo ns parser and filesystem cache', async () => {
+    const app = new App({ cwd: rootDir })
+    const bajo = new Bajo(app)
+    app.bajo = bajo
+    bajo.dir = {
+      base: rootDir,
+      data: path.join(rootDir, 'data')
+    }
+    await fs.ensureDir(bajo.dir.data)
+
+    const content = { ok: true, items: [1, 2, 3] }
+    await app.cache.save('bajo.api:items/list', content, 60000)
+    const loaded = await app.cache.load('bajo.api:items/list', 60000)
+
+    expect(loaded).to.deep.equal(content)
+  })
+
+  it('integrates real full boot flow through index entry with disk plugin', async () => {
+    const pluginName = 'integration-plugin'
+    const pluginDir = path.join(rootDir, 'node_modules', pluginName)
+    await fs.ensureDir(pluginDir)
+    await fs.writeJson(path.join(rootDir, 'package.json'), {
+      name: 'bajo-integration-app',
+      type: 'module',
+      bajo: {
+        plugins: [pluginName]
+      }
+    })
+    await fs.writeJson(path.join(pluginDir, 'package.json'), {
+      name: pluginName,
+      version: '1.0.0',
+      type: 'module',
+      main: 'index.js'
+    })
+    await fs.writeFile(path.join(pluginDir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+
+  return class IntegrationPlugin extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = { started: false }
+      this.start = async () => {
+        this.state.started = true
+        const dir = this.app.getPluginDataDir(this.ns)
+        this.app.lib.fs.writeFileSync(dir + '/started.txt', 'ok', 'utf8')
+      }
+    }
+  }
+}
+
+export default factory
+`, 'utf8')
+
+    const dataDir = path.join(rootDir, 'data', 'config')
+    await fs.ensureDir(dataDir)
+    await fs.writeJson(path.join(dataDir, 'bajo.json'), {
+      log: { level: 'silent', save: false },
+      exitHandler: false,
+      cache: { purgeIntvDur: '1h' }
+    })
+
+    const events = ['SIGINT', 'SIGTERM', 'beforeExit', 'uncaughtException', 'unhandledRejection', 'warning']
+    const beforeCounts = events.reduce((acc, event) => {
+      acc[event] = process.listeners(event).length
+      return acc
+    }, {})
+
+    const originalSetInterval = global.setInterval
+    const createdIntervals = []
+    global.setInterval = (fn, delay, ...args) => {
+      const id = originalSetInterval(fn, delay, ...args)
+      createdIntervals.push(id)
+      return id
+    }
+
+    const app = await boot({ cwd: rootDir })
+
+    try {
+      expect(app).to.be.an('object')
+      expect(app.integrationPlugin).to.be.an('object')
+      const startedFile = path.join(rootDir, 'data', 'plugins', 'integrationPlugin', 'started.txt')
+      expect(fs.existsSync(startedFile)).to.equal(true)
+      expect(fs.readFileSync(startedFile, 'utf8')).to.equal('ok')
+    } finally {
+      global.setInterval = originalSetInterval
+      for (const id of createdIntervals) clearInterval(id)
+      cleanupNewProcessListeners(beforeCounts)
+    }
+  })
+})