bajo 2.23.0 → 2.25.0

package/test/helper.test.js

@@ -1,39 +0,0 @@
-/* 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

@@ -1,138 +0,0 @@
-/* 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

@@ -1,218 +0,0 @@
-/* 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)
-    }
-  })
-})

package/test/log.test.js

@@ -1,119 +0,0 @@
-/* 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 dayjs from 'dayjs'
-
-import Log from '../class/log.js'
-
-const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-log-test-'))
-
-describe('Log', () => {
-  let root
-  let app
-  let log
-
-  beforeEach(() => {
-    root = createTempRoot()
-    app = {
-      runAt: new Date(),
-      t: (prefix, text, ...args) => `${prefix}:${text}:${args.join('|')}`,
-      lib: {
-        fs,
-        dayjs,
-        _: {
-          isEmpty: (v) => v == null || v === '' || (typeof v === 'object' && Object.keys(v).length === 0),
-          merge: (a, b) => Object.assign(a, b),
-          without: (arr, item) => arr.filter(i => i !== item)
-        }
-      },
-      bajo: {
-        dir: { data: root },
-        config: {
-          env: 'dev',
-          log: {
-            level: 'trace',
-            save: false,
-            pretty: false,
-            useUtc: false,
-            timeTaken: false,
-            dateFormat: 'YYYY-MM-DD',
-            rotation: { cycle: 'none', byPlugin: false }
-          }
-        },
-        isLogInRange: () => true
-      }
-    }
-  })
-
-  afterEach(() => {
-    if (root) fs.rmSync(root, { recursive: true, force: true })
-  })
-
-  it('formats and prints messages in dev mode', () => {
-    const originalLog = console.log
-    const lines = []
-    console.log = (line) => lines.push(line)
-    log = new Log(app)
-
-    try {
-      log.info('main', 'hello %s', 'x')
-    } finally {
-      console.log = originalLog
-    }
-
-    expect(lines.length).to.equal(1)
-    expect(lines[0]).to.include('[INFO]')
-    expect(lines[0]).to.include('[main]')
-    expect(lines[0]).to.include('main:hello %s:x')
-  })
-
-  it('returns error message fallback by code/statusCode', () => {
-    log = new Log(app)
-
-    expect(log.getErrorMessage(new Error('x'))).to.equal('x')
-    expect(log.getErrorMessage({ message: '', code: 'E1' })).to.equal('E1')
-    expect(log.getErrorMessage({ message: '', statusCode: 404 })).to.equal(404)
-  })
-
-  it('builds rotation patterns and saves file', () => {
-    app.bajo.config.log.save = true
-    log = new Log(app)
-    app.bajo.config.log.rotation.cycle = 'daily'
-
-    const pattern = log.getRotationPattern()
-    log.save('\u001b[31mhello\u001b[0m', 'x')
-
-    expect(pattern).to.be.a('string')
-    expect(fs.existsSync(path.join(root, 'log', `bajo.${pattern}.log`))).to.equal(true)
-  })
-
-  it('supports prod json output', () => {
-    app.bajo.config.env = 'prod'
-    log = new Log(app)
-    const originalLog = console.log
-    const lines = []
-    console.log = (line) => lines.push(line)
-
-    try {
-      log.warn('core', { id: 1 }, 'hi')
-    } finally {
-      console.log = originalLog
-    }
-
-    const payload = JSON.parse(lines[0])
-    expect(payload.prefix).to.equal('core')
-    expect(payload.level).to.be.a('number')
-    expect(payload).to.have.property('data')
-  })
-
-  it('disposes app reference', async () => {
-    log = new Log(app)
-
-    await log.dispose()
-
-    expect(log.app).to.equal(null)
-  })
-})

package/test/plugin.test.js

@@ -1,116 +0,0 @@
-/* global describe, it, beforeEach */
-
-import os from 'node:os'
-import path from 'node:path'
-import { expect } from 'chai'
-import fs from 'fs-extra'
-import lodash from 'lodash'
-
-import Plugin from '../class/plugin.js'
-
-const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-plugin-test-'))
-
-describe('Plugin', () => {
-  let app
-
-  beforeEach(() => {
-    const calls = []
-    app = {
-      lib: {
-        _: lodash,
-        fs
-      },
-      log: {
-        trace: (...args) => calls.push(['trace', ...args]),
-        debug: (...args) => calls.push(['debug', ...args]),
-        info: (...args) => calls.push(['info', ...args]),
-        warn: (...args) => calls.push(['warn', ...args]),
-        error: (...args) => calls.push(['error', ...args]),
-        fatal: (...args) => calls.push(['fatal', ...args]),
-        silent: (...args) => calls.push(['silent', ...args])
-      },
-      t: (ns, text, ...params) => `${ns}:${text}:${params.join('|')}`,
-      te: (ns, text) => `${ns}:${text}`,
-      dump: (...args) => calls.push(['dump', ...args]),
-      _calls: calls
-    }
-  })
-
-  it('initializes namespace and prefixed log shortcuts', () => {
-    const plugin = new Plugin('my-plugin', app)
-
-    plugin.log.info('hello')
-
-    expect(plugin.ns).to.equal('myPlugin')
-    expect(app._calls[0]).to.deep.equal(['info', 'myPlugin', 'hello'])
-  })
-
-  it('reads package info and selected keys', async () => {
-    const root = createTempRoot()
-    const pkgDir = path.join(root, 'plugin')
-    await fs.ensureDir(pkgDir)
-    await fs.writeJson(path.join(pkgDir, 'package.json'), {
-      name: 'my-plugin',
-      version: '1.2.3',
-      private: true
-    })
-    const plugin = new Plugin('my-plugin', app)
-    plugin.dir = { pkg: pkgDir }
-
-    expect(plugin.getPkgInfo()).to.deep.equal({
-      name: 'my-plugin',
-      version: '1.2.3'
-    })
-    expect(plugin.getPkgInfo(pkgDir, [])).to.include({ private: true })
-  })
-
-  it('returns config value with clone and omit support', () => {
-    const plugin = new Plugin('my-plugin', app)
-    plugin.config = { a: { b: 1, c: 2 } }
-
-    const val = plugin.getConfig('a', { omit: ['c'] })
-    val.b = 99
-
-    expect(val).to.deep.equal({ b: 99 })
-    expect(plugin.config.a.b).to.equal(1)
-    expect(plugin.getConfig('missing', { defValue: { x: 1 } })).to.deep.equal({ x: 1 })
-    expect(plugin.getConfig('a', { noClone: true })).to.equal(plugin.config.a)
-  })
-
-  it('returns native Error when print is unavailable', () => {
-    const plugin = new Plugin('my-plugin', app)
-
-    const err = plugin.error('plain error')
-    const fatalErr = plugin.fatal('fatal error')
-
-    expect(err).to.be.instanceOf(Error)
-    expect(err.message).to.equal('plain error')
-    expect(fatalErr).to.be.instanceOf(Error)
-  })
-
-  it('delegates translation and dump to app', () => {
-    const plugin = new Plugin('my-plugin', app)
-
-    expect(plugin.t('hello', 'x')).to.equal('myPlugin:hello:x')
-    expect(plugin.te('hello')).to.equal('myPlugin:hello')
-    plugin.dump(1, 2)
-
-    expect(app._calls[0]).to.deep.equal(['dump', 1, 2])
-  })
-
-  it('binds methods and disposes references', async () => {
-    const plugin = new Plugin('my-plugin', app)
-    plugin.value = 42
-    plugin.read = function () {
-      return this.value
-    }
-
-    plugin.selfBind('read')
-    const reader = plugin.read
-    await plugin.dispose()
-
-    expect(reader()).to.equal(42)
-    expect(plugin.app).to.equal(null)
-    expect(plugin.config).to.equal(null)
-  })
-})