bajo 2.23.0 → 2.24.0

package/test/00-global-hooks.test.js

@@ -0,0 +1,44 @@
+/* global beforeEach, afterEach */
+
+const state = {
+  originalSetInterval: null,
+  createdIntervals: [],
+  listenerCounts: null
+}
+
+beforeEach(() => {
+  state.createdIntervals = []
+  state.listenerCounts = {
+    SIGINT: process.listeners('SIGINT').length,
+    SIGTERM: process.listeners('SIGTERM').length,
+    beforeExit: process.listeners('beforeExit').length,
+    uncaughtException: process.listeners('uncaughtException').length,
+    unhandledRejection: process.listeners('unhandledRejection').length,
+    warning: process.listeners('warning').length
+  }
+
+  if (!state.originalSetInterval) state.originalSetInterval = global.setInterval
+  global.setInterval = (fn, delay, ...args) => {
+    const id = state.originalSetInterval(fn, delay, ...args)
+    state.createdIntervals.push(id)
+    return id
+  }
+})
+
+afterEach(() => {
+  if (state.originalSetInterval) {
+    global.setInterval = state.originalSetInterval
+  }
+  for (const id of state.createdIntervals) {
+    clearInterval(id)
+  }
+
+  for (const event of Object.keys(state.listenerCounts)) {
+    const listeners = process.listeners(event)
+    const keep = state.listenerCounts[event]
+    if (listeners.length <= keep) continue
+    for (const listener of listeners.slice(keep)) {
+      process.removeListener(event, listener)
+    }
+  }
+})

package/test/e2e/_run.js

@@ -0,0 +1,19 @@
+import { spawn } from 'node:child_process'
+
+export const runNode = (cwd, file, timeoutMs = 15000) => {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [file], { cwd, stdio: ['ignore', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', c => { stdout += c.toString() })
+    child.stderr.on('data', c => { stderr += c.toString() })
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM')
+      resolve({ code: null, timedOut: true, stdout, stderr })
+    }, timeoutMs)
+    child.on('close', code => {
+      clearTimeout(timer)
+      resolve({ code, timedOut: false, stdout, stderr })
+    })
+  })
+}

package/test/e2e/e2e-applet-process.test.js

@@ -0,0 +1,66 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import { runNode } from './_run.js'
+
+describe('e2e applet process', () => {
+  let root
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-e2e-applet-'))
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('runs applet path in separate process with real plugin', async function () {
+    this.timeout(25000)
+
+    const entry = pathToFileURL(path.join('/mnt/d/Projects/Bajo/bajo', 'index.js')).href
+    const pluginName = 'bajo-cli'
+    const pdir = path.join(root, 'node_modules', pluginName)
+
+    await fs.ensureDir(pdir)
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'e2e-app', type: 'module', bajo: { plugins: [pluginName] } })
+    await fs.writeJson(path.join(pdir, 'package.json'), { name: pluginName, version: '1.0.0', type: 'module', main: 'index.js' })
+    await fs.writeFile(path.join(pdir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+  return class BajoCli extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = {}
+    }
+    runApplet = async () => {
+      await this.app.lib.fs.writeFile(this.app.dir + '/e2e-applet.txt', 'ran', 'utf8')
+    }
+  }
+}
+export default factory
+`, 'utf8')
+
+    await fs.ensureDir(path.join(pdir, 'extend', 'bajoCli'))
+    await fs.writeFile(path.join(pdir, 'extend', 'bajoCli', 'applet.js'), 'export default function () { return { name: "noop" } }', 'utf8')
+
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'data', 'config', 'bajo.json'), { log: { level: 'silent', save: false }, exitHandler: false, cache: { purgeIntvDur: '1h' } })
+
+    await fs.writeFile(path.join(root, 'run-app.mjs'), `
+process.argv = ['node', 'index.js', '--applet=bajoCli:noop']
+import boot from ${JSON.stringify(entry)}
+await boot({ cwd: process.cwd() })
+console.log('APPLET_OK')
+process.exit(0)
+`, 'utf8')
+
+    const res = await runNode(root, 'run-app.mjs')
+    expect(res.timedOut).to.equal(false)
+    expect(res.code).to.equal(0)
+    expect(res.stdout).to.include('APPLET_OK')
+    expect(fs.existsSync(path.join(root, 'e2e-applet.txt'))).to.equal(true)
+  })
+})

package/test/e2e/e2e-boot-process.test.js

@@ -0,0 +1,62 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import { runNode } from './_run.js'
+
+describe('e2e boot process', () => {
+  let root
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-e2e-boot-'))
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('boots real app in separate process and runs plugin start', async function () {
+    this.timeout(20000)
+
+    const entry = pathToFileURL(path.join('/mnt/d/Projects/Bajo/bajo', 'index.js')).href
+    const pluginName = 'e2e-plugin-boot'
+    const pdir = path.join(root, 'node_modules', pluginName)
+
+    await fs.ensureDir(pdir)
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'e2e-app', type: 'module', bajo: { plugins: [pluginName] } })
+    await fs.writeJson(path.join(pdir, 'package.json'), { name: pluginName, version: '1.0.0', type: 'module', main: 'index.js' })
+    await fs.writeFile(path.join(pdir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+  return class E2EPluginBoot 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-boot.txt', 'started', 'utf8')
+      }
+    }
+  }
+}
+export default factory
+`, 'utf8')
+
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'data', 'config', 'bajo.json'), { log: { level: 'silent', save: false }, exitHandler: false, cache: { purgeIntvDur: '1h' } })
+
+    await fs.writeFile(path.join(root, 'run-app.mjs'), `
+import boot from ${JSON.stringify(entry)}
+const app = await boot({ cwd: process.cwd() })
+console.log('BOOT_OK:' + !!app.getPlugin(${JSON.stringify(pluginName)}, true))
+process.exit(0)
+`, 'utf8')
+
+    const res = await runNode(root, 'run-app.mjs')
+    expect(res.timedOut).to.equal(false)
+    expect(res.code).to.equal(0)
+    expect(res.stdout).to.include('BOOT_OK:true')
+    expect(fs.existsSync(path.join(root, 'e2e-boot.txt'))).to.equal(true)
+  })
+})

package/test/e2e/e2e-hooks-process.test.js

@@ -0,0 +1,68 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import { runNode } from './_run.js'
+
+describe('e2e hooks process', () => {
+  let root
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-e2e-hooks-'))
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('executes real plugin hooks in separate process', async function () {
+    this.timeout(20000)
+
+    const entry = pathToFileURL(path.join('/mnt/d/Projects/Bajo/bajo', 'index.js')).href
+    const pluginName = 'e2e-plugin-hooks'
+    const pdir = path.join(root, 'node_modules', pluginName)
+
+    await fs.ensureDir(path.join(pdir, 'extend', 'bajo', 'hook'))
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'e2e-app', type: 'module', bajo: { plugins: [pluginName] } })
+    await fs.writeJson(path.join(pdir, 'package.json'), { name: pluginName, version: '1.0.0', type: 'module', main: 'index.js' })
+    await fs.writeFile(path.join(pdir, 'index.js'), `
+async function factory (pkgName) {
+  const me = this
+  return class E2EPluginHooks extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = {}
+    }
+  }
+}
+export default factory
+`, 'utf8')
+
+    await fs.writeFile(path.join(pdir, 'extend', 'bajo', 'hook', 'bajo@after-boot.js'), `
+export default {
+  level: 1,
+  handler: async function () {
+    await this.app.lib.fs.writeFile(this.app.dir + '/e2e-hook.txt', 'done', 'utf8')
+  }
+}
+`, 'utf8')
+
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'data', 'config', 'bajo.json'), { log: { level: 'silent', save: false }, exitHandler: false, cache: { purgeIntvDur: '1h' } })
+
+    await fs.writeFile(path.join(root, 'run-app.mjs'), `
+import boot from ${JSON.stringify(entry)}
+await boot({ cwd: process.cwd() })
+console.log('HOOK_OK')
+process.exit(0)
+`, 'utf8')
+
+    const res = await runNode(root, 'run-app.mjs')
+    expect(res.timedOut).to.equal(false)
+    expect(res.code).to.equal(0)
+    expect(res.stdout).to.include('HOOK_OK')
+    expect(fs.existsSync(path.join(root, 'e2e-hook.txt'))).to.equal(true)
+  })
+})

package/test/integration/_setup.js

@@ -0,0 +1,55 @@
+import path from 'node:path'
+import fs from 'fs-extra'
+
+export const makeRoot = (prefix = 'bajo-int-') => fs.mkdtempSync(path.join('/tmp', prefix))
+
+export const cleanupRoot = (root) => {
+  if (root) fs.rmSync(root, { recursive: true, force: true })
+}
+
+export const writeBaseApp = async (root, pluginName, extraBajoConfig = {}) => {
+  await fs.writeJson(path.join(root, 'package.json'), {
+    name: 'bajo-int-app',
+    type: 'module',
+    bajo: { plugins: [pluginName] }
+  })
+
+  await fs.ensureDir(path.join(root, 'data', 'config'))
+  await fs.writeJson(path.join(root, 'data', 'config', 'bajo.json'), {
+    env: 'dev',
+    lang: 'en-US',
+    exitHandler: false,
+    log: { level: 'silent', save: false },
+    cache: { purgeIntvDur: '1h' },
+    ...extraBajoConfig
+  })
+}
+
+export const writePlugin = async (root, pluginName, className = 'IntegrationPlugin', startBody = '') => {
+  const pluginDir = path.join(root, 'node_modules', pluginName)
+  await fs.ensureDir(pluginDir)
+  await fs.writeJson(path.join(pluginDir, 'package.json'), {
+    name: pluginName,
+    version: '1.0.0',
+    type: 'module',
+    main: 'index.js'
+  })
+
+  const code = `
+async function factory (pkgName) {
+  const me = this
+  return class ${className} extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = { marker: 'ok', feature: true }
+      this.start = async () => {
+        ${startBody}
+      }
+    }
+  }
+}
+export default factory
+`
+  await fs.writeFile(path.join(pluginDir, 'index.js'), code, 'utf8')
+  return pluginDir
+}

package/test/integration/aspect-01-boot-instance.test.js

@@ -0,0 +1,24 @@
+/* global describe, it, beforeEach, afterEach */
+
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 01 - boot instance', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a01-')
+    await writeBaseApp(root, 'int-a01-plugin')
+    await writePlugin(root, 'int-a01-plugin', 'IntA01', "await this.app.lib.fs.writeFile(this.app.dir + '/a01.txt', 'ok', 'utf8')")
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('boots app instance successfully', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    expect(app).to.be.an('object')
+    expect(app.bajo).to.be.an('object')
+  })
+})

package/test/integration/aspect-02-plugin-loading.test.js

@@ -0,0 +1,24 @@
+/* global describe, it, beforeEach, afterEach */
+
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 02 - plugin loading', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a02-')
+    await writeBaseApp(root, 'int-a02-plugin')
+    await writePlugin(root, 'int-a02-plugin', 'IntA02', "this.state.started = true")
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('loads plugin and keeps namespace mapping', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    expect(app.intA02Plugin).to.be.an('object')
+    expect(app.getAllNs()).to.include('intA02Plugin')
+  })
+})

package/test/integration/aspect-03-config-merge.test.js

@@ -0,0 +1,27 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 03 - config merge', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a03-')
+    await writeBaseApp(root, 'int-a03-plugin')
+    await writePlugin(root, 'int-a03-plugin', 'IntA03', '')
+    await fs.writeJson(path.join(root, 'data', 'config', 'intA03Plugin.json'), { marker: 'override', feature: false })
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('merges plugin runtime config from data/config', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    expect(app.intA03Plugin.getConfig('marker')).to.equal('override')
+    expect(app.intA03Plugin.getConfig('feature')).to.equal(false)
+  })
+})

package/test/integration/aspect-04-intl-loading.test.js

@@ -0,0 +1,29 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 04 - intl loading', () => {
+  let root
+  let pluginDir
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a04-')
+    await writeBaseApp(root, 'int-a04-plugin')
+    pluginDir = await writePlugin(root, 'int-a04-plugin', 'IntA04', '')
+    await fs.ensureDir(path.join(pluginDir, 'extend', 'bajo', 'intl'))
+    await fs.writeJson(path.join(pluginDir, 'extend', 'bajo', 'intl', 'en-US.json'), { hello: 'Hello %s' })
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('loads plugin translation file and translates text', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    expect(app.intA04Plugin.intl['en-US'].hello).to.equal('Hello %s')
+    expect(app.t('intA04Plugin', 'hello', 'Joe')).to.equal('Hello Joe')
+  })
+})

package/test/integration/aspect-05-cache-roundtrip.test.js

@@ -0,0 +1,26 @@
+/* global describe, it, beforeEach, afterEach */
+
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 05 - cache roundtrip', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a05-')
+    await writeBaseApp(root, 'int-a05-plugin')
+    await writePlugin(root, 'int-a05-plugin', 'IntA05', '')
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('persists and reads cache values through app.cache', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    const payload = { ok: true, ids: [1, 2, 3] }
+    await app.cache.save('bajo.demo:path/item', payload, 60000)
+    const loaded = await app.cache.load('bajo.demo:path/item', 60000)
+    expect(loaded).to.deep.equal(payload)
+  })
+})

package/test/integration/aspect-06-log-file-save.test.js

@@ -0,0 +1,28 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 06 - log save', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a06-')
+    await writeBaseApp(root, 'int-a06-plugin', { log: { level: 'trace', save: true, pretty: false, useUtc: false, timeTaken: false, dateFormat: 'YYYY-MM-DD', rotation: { cycle: 'none', byPlugin: false } } })
+    await writePlugin(root, 'int-a06-plugin', 'IntA06', '')
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('writes log file when save is enabled', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    app.log.info('demo', 'saved%s', 'ok')
+    const logFile = path.join(root, 'data', 'log', 'bajo.log')
+    expect(fs.existsSync(logFile)).to.equal(true)
+    expect(fs.readFileSync(logFile, 'utf8')).to.include('saved')
+  })
+})

package/test/integration/aspect-07-plugin-data-dir.test.js

@@ -0,0 +1,25 @@
+/* global describe, it, beforeEach, afterEach */
+
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 07 - plugin data dir', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a07-')
+    await writeBaseApp(root, 'int-a07-plugin')
+    await writePlugin(root, 'int-a07-plugin', 'IntA07', "const d = this.app.getPluginDataDir(this.ns); this.app.lib.fs.writeFileSync(d + '/ready.txt', '1', 'utf8')")
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('creates plugin data dir and allows writes during plugin start', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    const d = app.getPluginDataDir('intA07Plugin')
+    expect(fs.existsSync(d + '/ready.txt')).to.equal(true)
+  })
+})

package/test/integration/aspect-08-plugin-lookup.test.js

@@ -0,0 +1,25 @@
+/* global describe, it, beforeEach, afterEach */
+
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 08 - plugin lookup', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a08-')
+    await writeBaseApp(root, 'int-a08-plugin')
+    await writePlugin(root, 'int-a08-plugin', 'IntA08', '')
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('resolves plugin by namespace and package name', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    const byNs = app.getPlugin('intA08Plugin')
+    const byPkg = app.getPlugin('int-a08-plugin')
+    expect(byNs).to.equal(byPkg)
+  })
+})

package/test/integration/aspect-09-config-formats.test.js

@@ -0,0 +1,26 @@
+/* global describe, it, beforeEach, afterEach */
+
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 09 - config formats', () => {
+  let root
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a09-')
+    await writeBaseApp(root, 'int-a09-plugin')
+    await writePlugin(root, 'int-a09-plugin', 'IntA09', '')
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('provides config format registry from runtime handlers', async function () {
+    this.timeout(12000)
+    const app = await boot({ cwd: root })
+    const exts = app.getConfigFormats()
+    expect(exts).to.include('.json')
+    expect(exts).to.include('.yml')
+    expect(app.getConfigFormats(true)).to.include('json')
+  })
+})

package/test/integration/aspect-10-hooks.test.js

@@ -0,0 +1,38 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import boot from '../../index.js'
+import { makeRoot, cleanupRoot, writeBaseApp, writePlugin } from './_setup.js'
+
+describe('integration aspect 10 - hook execution', () => {
+  let root
+  let pluginDir
+
+  beforeEach(async () => {
+    root = makeRoot('bajo-int-a10-')
+    await writeBaseApp(root, 'int-a10-plugin')
+    pluginDir = await writePlugin(root, 'int-a10-plugin', 'IntA10', "await this.app.lib.fs.writeFile(this.app.dir + '/plugin-start.txt', 'started', 'utf8')")
+
+    const hookDir = path.join(pluginDir, 'extend', 'bajo', 'hook')
+    await fs.ensureDir(hookDir)
+    await fs.writeFile(path.join(hookDir, 'bajo@after-boot.js'), `
+export default {
+  level: 100,
+  handler: async function () {
+    await this.app.lib.fs.writeFile(this.app.dir + '/after-boot.txt', 'ok', 'utf8')
+  }
+}
+`, 'utf8')
+  })
+
+  afterEach(() => cleanupRoot(root))
+
+  it('collects and runs plugin hook during boot lifecycle', async function () {
+    this.timeout(12000)
+    await boot({ cwd: root })
+    expect(fs.existsSync(path.join(root, 'plugin-start.txt'))).to.equal(true)
+    expect(fs.existsSync(path.join(root, 'after-boot.txt'))).to.equal(true)
+  })
+})