bajo 2.23.0 → 2.25.0

package/test/app.test.js

@@ -1,183 +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 Plugin from '../class/plugin.js'
-
-const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-app-test-'))
-
-describe('App', () => {
-  let rootDir
-  let app
-
-  beforeEach(() => {
-    rootDir = createTempRoot()
-    app = new App({ cwd: rootDir })
-  })
-
-  afterEach(() => {
-    if (rootDir) fs.rmSync(rootDir, { recursive: true, force: true })
-  })
-
-  it('adds plugins and base class mappings', () => {
-    const plugin = new Plugin('my-plugin', app)
-    const MyBase = class {}
-
-    app.addPlugin(plugin, MyBase)
-
-    expect(app.myPlugin).to.equal(plugin)
-    expect(app.baseClass.MyPlugin).to.equal(MyBase)
-  })
-
-  it('throws when adding the same plugin namespace twice', () => {
-    const plugin = new Plugin('dup-plugin', app)
-    app.addPlugin(plugin)
-
-    expect(() => app.addPlugin(plugin)).to.throw("Plugin 'dupPlugin' added already")
-  })
-
-  it('lists namespaces and loaded plugins', () => {
-    app.pluginPkgs = ['alpha-plugin', 'beta-plugin']
-    app.alphaPlugin = { ns: 'alphaPlugin' }
-    app.betaPlugin = { ns: 'betaPlugin' }
-
-    expect(app.getAllNs()).to.deep.equal(['alphaPlugin', 'betaPlugin'])
-    expect(app.getPlugins()).to.deep.equal([app.alphaPlugin, app.betaPlugin])
-    expect(app.getPlugins(['betaPlugin'])).to.deep.equal([app.betaPlugin])
-    expect(app.getAllPlugins()).to.deep.equal([app.alphaPlugin, app.betaPlugin])
-  })
-
-  it('gets plugin by namespace, alias, and package name', () => {
-    const plugin = new Plugin('my-plugin', app)
-    plugin.alias = 'mine'
-    app.addPlugin(plugin)
-    app.bajo = { error: (code, value) => new Error(`${code}:${value}`) }
-
-    expect(app.getPlugin('myPlugin')).to.equal(plugin)
-    expect(app.getPlugin('mine')).to.equal(plugin)
-    expect(app.getPlugin('my-plugin')).to.equal(plugin)
-  })
-
-  it('supports silent and throwing behavior for missing plugin lookup', () => {
-    app.bajo = { error: (code, value) => new Error(`${code}:${value}`) }
-
-    expect(app.getPlugin('missing', true)).to.equal(false)
-    expect(() => app.getPlugin('missing')).to.throw('pluginWithNameAliasNotLoaded%s:missing')
-  })
-
-  it('creates and returns plugin data directory', () => {
-    const plugin = new Plugin('my-plugin', app)
-    app.addPlugin(plugin)
-    app.bajo = { dir: { data: path.join(rootDir, 'data') } }
-
-    const dir = app.getPluginDataDir('myPlugin')
-
-    expect(dir).to.equal(path.join(rootDir, 'data', 'plugins', 'myPlugin'))
-    expect(fs.existsSync(dir)).to.equal(true)
-  })
-
-  it('resolves plugin-scoped files and node_modules fallback paths', async () => {
-    const plugin = new Plugin('my-plugin', app)
-    plugin.dir = { pkg: path.join(rootDir, 'plugins', 'my-plugin') }
-    await fs.ensureDir(plugin.dir.pkg)
-    app.addPlugin(plugin)
-
-    app.bajo = {
-      breakNsPath: () => ({ ns: 'myPlugin', path: '/src/feature.js' })
-    }
-    expect(app.getPluginFile('myPlugin:/src/feature.js')).to.equal(path.join(plugin.dir.pkg, 'src/feature.js'))
-
-    const fallbackFile = path.join(rootDir, 'plugins', 'dep', 'index.js')
-    await fs.ensureDir(path.dirname(fallbackFile))
-    await fs.writeFile(fallbackFile, 'export default 1', 'utf8')
-    app.bajo.breakNsPath = () => ({ ns: 'myPlugin', path: 'node_modules/dep/index.js' })
-
-    expect(app.getPluginFile('myPlugin:node_modules/dep/index.js')).to.equal(`${plugin.dir.pkg}/../dep/index.js`)
-  })
-
-  it('translates and checks translation existence', () => {
-    app.pluginPkgs = ['my-plugin']
-    app.myPlugin = {
-      intl: {
-        id: {
-          greet: 'Halo %s',
-          list: 'Daftar: %s'
-        },
-        en: {
-          greet: 'Hello %s'
-        }
-      }
-    }
-    app.bajo = {
-      config: {
-        lang: 'id',
-        intl: {
-          fallback: 'en',
-          supported: ['id', 'en']
-        }
-      },
-      join: (items) => items.join(', '),
-      log: { warn: () => {} }
-    }
-
-    expect(app.t('myPlugin', 'greet', 'Ardhi')).to.equal('Halo Ardhi')
-    expect(app.t('myPlugin', 'list', ['A', 'B'])).to.equal('Daftar: A, B')
-    expect(app.t('myPlugin', 'unknown %s', 'X')).to.equal('unknown X')
-    expect(app.te('myPlugin', 'greet')).to.equal(true)
-    expect(app.te('myPlugin', 'not.exists')).to.equal(false)
-  })
-
-  it('returns supported config formats', () => {
-    app.configHandlers = [{ ext: '.json' }, { ext: '.yaml' }]
-
-    expect(app.getConfigFormats()).to.deep.equal(['.json', '.yaml'])
-  })
-
-  it('starts plugin by namespace with arguments', () => {
-    const calls = []
-    app.sample = {
-      start: (...args) => {
-        calls.push(args)
-      }
-    }
-
-    app.startPlugin('sample', 1, 'x')
-
-    expect(calls).to.deep.equal([[1, 'x']])
-  })
-
-  it('kills process with signal and exits abruptly when true is passed', () => {
-    const originalKill = process.kill
-    const originalExit = process.exit
-    const killCalls = []
-    let exitArg
-
-    process.kill = (...args) => {
-      killCalls.push(args)
-      return true
-    }
-    process.exit = (arg) => {
-      exitArg = arg
-      throw new Error('__EXIT__')
-    }
-
-    try {
-      app.exit('SIGTERM')
-      try {
-        app.exit(true)
-      } catch (err) {
-        if (err.message !== '__EXIT__') throw err
-      }
-    } finally {
-      process.kill = originalKill
-      process.exit = originalExit
-    }
-
-    expect(killCalls).to.deep.equal([[process.pid, 'SIGTERM']])
-    expect(exitArg).to.equal('1')
-  })
-})

package/test/bajo.test.js

@@ -1,124 +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'
-
-const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-core-test-'))
-
-describe('Bajo', () => {
-  let root
-  let app
-  let bajo
-
-  beforeEach(() => {
-    root = createTempRoot()
-    app = new App({ cwd: root })
-    bajo = new Bajo(app)
-    app.bajo = bajo
-    app.main = { dir: { pkg: root } }
-    app.mainNs = 'main'
-    app.main = { pkgName: 'main', dir: { pkg: root } }
-    app.demo = {
-      dir: { pkg: path.join(root, 'demo') },
-      greet: (name) => `hi ${name}`
-    }
-    bajo.config = {
-      env: 'dev',
-      lang: 'en-US',
-      intl: {
-        unitSys: { 'en-US': 'metric' },
-        format: {
-          emptyValue: '-',
-          datetime: { dateStyle: 'medium', timeStyle: 'short', timeZone: 'UTC' },
-          date: { dateStyle: 'medium', timeZone: 'UTC' },
-          time: { timeStyle: 'short', timeZone: 'UTC' },
-          float: { maximumFractionDigits: 2 },
-          double: { maximumFractionDigits: 2 },
-          integer: {},
-          smallint: {}
-        }
-      },
-      log: {
-        level: 'trace'
-      }
-    }
-    bajo.t = (text) => text
-  })
-
-  afterEach(() => {
-    if (root) fs.rmSync(root, { recursive: true, force: true })
-  })
-
-  it('builds and breaks namespace paths', () => {
-    const built = bajo.buildNsPath({ ns: 'demo', subNs: 'api', subSubNs: 'v1', path: '/users' })
-    const broken = bajo.breakNsPath('demo.api:/users/:id|42?q=x')
-
-    expect(built).to.equal('demo.api.v1:/users')
-    expect(broken).to.include({ ns: 'demo', subNs: 'api', path: '/users/:id', realPath: '/users/42' })
-    expect(broken.qs).to.deep.equal({ q: 'x' })
-  })
-
-  it('breaks ns path details from filename', () => {
-    const info = bajo.breakNsPathFromFile({
-      file: 'x/extend/route/demo.api@user-list.js',
-      dir: 'x/extend/',
-      suffix: '',
-      ns: 'demo',
-      getType: true
-    })
-
-    expect(info).to.include({ ns: 'demo', subNs: 'api', path: 'userList', type: 'route' })
-  })
-
-  it('returns unit format and formats values', () => {
-    const unit = bajo.getUnitFormat({ lang: 'en-US' })
-    const joined = bajo.format(['a', 'b'], 'array')
-    const integer = bajo.format(12345, 'integer')
-
-    expect(unit.unitSys).to.equal('metric')
-    expect(unit.format).to.be.an('object')
-    expect(joined).to.equal('a, b')
-    expect(integer).to.be.a('string')
-  })
-
-  it('gets method by ns path and supports non-throw mode', () => {
-    const fn = bajo.getMethod('demo:greet')
-    const miss = bajo.getMethod('demo:notFound', false)
-
-    expect(fn('a')).to.equal('hi a')
-    expect(miss).to.equal(undefined)
-  })
-
-  it('validates app/plugin package and utility helpers', async () => {
-    const appPkg = path.join(root, 'appdir')
-    const pluginPkg = path.join(root, 'plugindir')
-    await fs.ensureDir(appPkg)
-    await fs.ensureDir(pluginPkg)
-    await fs.ensureDir(path.join(root, 'empty'))
-    await fs.writeJson(path.join(appPkg, 'package.json'), { bajo: { type: 'app' } })
-    await fs.writeJson(path.join(pluginPkg, 'package.json'), { bajo: { type: 'plugin' } })
-
-    expect(bajo.isValidApp(appPkg)).to.equal(true)
-    expect(bajo.isValidPlugin(pluginPkg)).to.equal(true)
-    expect(bajo.join(['a', 'b', 'c'])).to.equal('a, b and c')
-    expect(bajo.numUnit('10mb', 'kb')).to.equal('10mb')
-  })
-
-  it('reads/writes json helpers', async () => {
-    const file = path.join(root, 'x.json')
-    const content = bajo.toJson({ a: 1 })
-    await fs.writeFile(file, content, 'utf8')
-
-    expect(bajo.fromJson(content)).to.deep.equal({ a: 1 })
-    expect(bajo.readJson(file)).to.deep.equal({ a: 1 })
-
-    const out = path.join(root, 'out.json')
-    bajo.toJson({ b: 2 }, { writeToFile: true, saveAsFile: out })
-    expect(fs.existsSync(out)).to.equal(true)
-  })
-})

package/test/base.test.js

@@ -1,75 +0,0 @@
-/* global describe, it, beforeEach */
-
-import { expect } from 'chai'
-import lodash from 'lodash'
-
-import Base from '../class/base.js'
-
-describe('Base', () => {
-  let app
-
-  beforeEach(() => {
-    app = {
-      mainNs: 'main',
-      getAllNs: () => ['alpha', 'beta'],
-      lib: {
-        _: lodash,
-        aneka: {
-          defaultsDeep: (...objs) => lodash.defaultsDeep(...objs)
-        },
-        parseObject: (obj) => obj
-      },
-      bajo: {
-        dir: { base: '/app', data: '/data' },
-        config: { env: 'dev' },
-        log: { trace: () => {} },
-        getModuleDir: () => '/modules/my-plugin',
-        readAllConfigs: async () => ({ fromFile: true })
-      },
-      env: {
-        myPlugin: { x: 3 }
-      },
-      argv: {
-        myPlugin: { y: 2 }
-      },
-      options: {
-        config: {
-          myPlugin: { z: 1 }
-        }
-      }
-    }
-  })
-
-  it('initializes defaults', () => {
-    const base = new Base('my-plugin', app)
-
-    expect(base.ns).to.equal('myPlugin')
-    expect(base.dependencies).to.deep.equal([])
-    expect(base.state).to.deep.equal({})
-    expect(base.pkg).to.deep.equal({})
-  })
-
-  it('loads config and sets package/data directories', async () => {
-    const base = new Base('my-plugin', app)
-    base.config = { title: 'my app', z: 9, x: 0, y: 0 }
-
-    await base.loadConfig()
-
-    expect(base.dir).to.deep.equal({
-      pkg: '/modules/my-plugin',
-      data: '/data/plugins/myPlugin'
-    })
-    expect(base.getConfig('x')).to.equal(3)
-    expect(base.getConfig('y')).to.equal(2)
-    expect(base.getConfig('z')).to.equal(1)
-    expect(base.getConfig('title')).to.equal('my app')
-  })
-
-  it('runs no-op lifecycle methods and exits by disposing', async () => {
-    const base = new Base('my-plugin', app)
-
-    await base.init()
-    await base.start()
-    await base.stop()
-  })
-})

package/test/cache.test.js

@@ -1,94 +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 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

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

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