@bhooai/nexus-core 2.0.13 → 2.0.15

package/src/app/databaseAdminModule.ts

@@ -1,7 +1,19 @@
 import type { Router } from '../index.js';
+import type { ActiveDatabase } from '../config/types.js';
+import { getAppFusion } from './fusionEngine.js';
+import type { FusionDatabase } from '@bhooai/nexus-fusion';
 
 /**
- * Admin routes for MongoDB database / collection administration.
+ * Admin routes for database / collection administration.
+ *
+ * MongoDB backend (default): full database/collection management with
+ * `$jsonSchema` validators (used by the AI schema generator).
+ *
+ * Fusion backend (`db.active: 'fusion'`): branches stand in for databases
+ * (routes keep the same paths); collections are implicit. Rename is
+ * copy-then-delete (the engine has no rename op); `$jsonSchema` validators
+ * are Mongo-only and rejected with a 400 explaining the alternative
+ * (`@bhooai/nexus-fusion/schemas` validation in code).
  *
  * The admin app uses these to create, rename and drop databases and
  * collections, and to preview documents. Collections can be created with a
@@ -27,10 +39,25 @@ const DOC_PREVIEW_LIMIT = 10;
 /** Ugly but real: dropping a db's only collection deletes the whole database. */
 const BOOTSTRAP_COLLECTION = '_nexus_bootstrap';
 
+/** Bootstrap doc id — materializes implicit Fusion collections; hidden from listings. */
+const BOOTSTRAP_DOC = '_nexus_bootstrap';
+
 /** Databases managed by MongoDB itself — hidden from the admin surface. */
 const SYSTEM_DATABASES = new Set(['admin', 'local', 'config']);
 
-export function registerDatabaseAdminRoutes(router: Router, lazy: LazyDb): void {
+export function registerDatabaseAdminRoutes(
+  router: Router,
+  lazy: LazyDb,
+  active: ActiveDatabase = 'mongodb',
+): void {
+  if (active === 'fusion') {
+    registerFusionDatabaseAdminRoutes(router);
+    return;
+  }
+  registerMongoDatabaseAdminRoutes(router, lazy);
+}
+
+function registerMongoDatabaseAdminRoutes(router: Router, lazy: LazyDb): void {
   router.get('/admin/databases', async (ctx) => {
     const db = await lazy.db();
     if (!db) { ctx.json({ error: 'MongoDB not reachable' }, 503); return; }
@@ -184,6 +211,148 @@ export function registerDatabaseAdminRoutes(router: Router, lazy: LazyDb): void
   });
 }
 
+function registerFusionDatabaseAdminRoutes(router: Router): void {
+  // Branches stand in for databases; the engine's fixed db is 'main'.
+  const view = (branch: string): FusionDatabase => getAppFusion().branchView(branch);
+
+  router.get('/admin/databases', async (ctx) => {
+    try {
+      const fusion = getAppFusion();
+      const databases = [];
+      for (const branch of fusion.listBranches()) {
+        const bcols = view(branch).listCollections().filter((c) => c !== BOOTSTRAP_COLLECTION);
+        const collections = [];
+        for (const c of bcols) {
+          let count = 0;
+          try {
+            const snap = await view(branch).collection(c).get();
+            count = snap.docs.filter((d) => d.id !== BOOTSTRAP_DOC).length;
+          } catch { /* stats unavailable */ }
+          collections.push({ name: c, count });
+        }
+        databases.push({ name: branch, sizeOnDisk: 0, collections });
+      }
+      ctx.json({ databases });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.post('/admin/databases', async (ctx) => {
+    const name = assertDbName((ctx.body as { name?: unknown } | undefined)?.name, ctx);
+    if (!name) return;
+    try {
+      getAppFusion().createBranch(name);
+      ctx.json({ ok: true, name });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.delete('/admin/databases/:db', async (ctx) => {
+    const name = assertDbName(ctx.params.db, ctx);
+    if (!name) return;
+    try {
+      getAppFusion().dropBranch(name);
+      ctx.json({ ok: true, dropped: name });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.post('/admin/databases/:db/collections', async (ctx) => {
+    const branch = assertDbName(ctx.params.db, ctx);
+    if (!branch) return;
+    const body = (ctx.body ?? {}) as { name?: unknown; jsonSchema?: unknown; validator?: unknown };
+    const name = assertCollectionName(body.name, ctx);
+    if (!name) return;
+    if (body.jsonSchema !== undefined || body.validator !== undefined) {
+      ctx.json({ error: '$jsonSchema validators are Mongo-only — validate with @bhooai/nexus-fusion/schemas in code instead' }, 400);
+      return;
+    }
+    try {
+      // Collections are implicit in Fusion — a bootstrap doc materializes it.
+      await view(branch).collection(name).doc(BOOTSTRAP_DOC).set({ _bootstrap: true });
+      ctx.json({ ok: true, db: branch, collection: name, validator: null });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.put('/admin/databases/:db/collections/:name', async (ctx) => {
+    const branch = assertDbName(ctx.params.db, ctx);
+    if (!branch) return;
+    const name = assertCollectionName(ctx.params.name, ctx);
+    if (!name) return;
+    const body = (ctx.body ?? {}) as { newName?: unknown; validator?: unknown };
+    if (body.validator !== undefined) {
+      ctx.json({ error: '$jsonSchema validators are Mongo-only — validate with @bhooai/nexus-fusion/schemas in code instead' }, 400);
+      return;
+    }
+    const changed: string[] = [];
+    try {
+      if (body.newName !== undefined) {
+        const newName = assertCollectionName(body.newName, ctx);
+        if (!newName) return;
+        if (newName !== name) {
+          // No engine rename op — copy then delete.
+          const snap = await view(branch).collection(name).get();
+          for (const d of snap.docs) {
+            if (d.id === BOOTSTRAP_DOC) continue;
+            await view(branch).collection(newName).doc(d.id).set(d.data as Record<string, unknown>);
+          }
+          for (const d of snap.docs) {
+            await view(branch).collection(name).doc(d.id).delete();
+          }
+          await view(branch).collection(newName).doc(BOOTSTRAP_DOC).set({ _bootstrap: true });
+          changed.push(`renamed to ${newName}`);
+        }
+      }
+      if (!changed.length) {
+        ctx.json({ error: 'nothing to modify — send newName' }, 400);
+        return;
+      }
+      ctx.json({ ok: true, db: branch, collection: name, changed });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.delete('/admin/databases/:db/collections/:name', async (ctx) => {
+    const branch = assertDbName(ctx.params.db, ctx);
+    if (!branch) return;
+    const name = assertCollectionName(ctx.params.name, ctx);
+    if (!name) return;
+    try {
+      const snap = await view(branch).collection(name).get();
+      for (const d of snap.docs) {
+        await view(branch).collection(name).doc(d.id).delete();
+      }
+      ctx.json({ ok: true, dropped: { db: branch, collection: name } });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+
+  router.get('/admin/databases/:db/collections/:name/docs', async (ctx) => {
+    const branch = assertDbName(ctx.params.db, ctx);
+    if (!branch) return;
+    const name = assertCollectionName(ctx.params.name, ctx);
+    if (!name) return;
+    try {
+      const snap = await view(branch).collection<Record<string, unknown>>(name).get();
+      const docs = snap.docs
+        .filter((d) => d.id !== BOOTSTRAP_DOC)
+        .slice(0, DOC_PREVIEW_LIMIT)
+        .map((d) => ({ id: d.id, ...d.data }));
+      const count = snap.docs.filter((d) => d.id !== BOOTSTRAP_DOC).length;
+      ctx.json({ db: branch, collection: name, count, docs });
+    } catch (err) {
+      ctx.json({ error: (err as Error).message }, 500);
+    }
+  });
+}
+
 function assertDbName(v: unknown, ctx: { json(data: unknown, status?: number): void; res: { writableEnded: boolean } }): string | null {
   const name = typeof v === 'string' ? v.trim() : '';
   if (!name || name.length > 63) { ctx.json({ error: 'database name is required (max 63 chars)' }, 400); return null; }

package/src/app/discover.ts

@@ -65,6 +65,7 @@ export interface DiscoveryResult {
   migrations: DiscoveredFile[];
   plugins: DiscoveredFile[];
   config: DiscoveredFile[];
+  live: DiscoveredFile[];
 }
 
 /**
@@ -74,7 +75,7 @@ export interface DiscoveryResult {
 export async function discoverBackend(srcRoot: string): Promise<DiscoveryResult> {
   const abs = resolve(srcRoot);
 
-  const [routes, graphql, rooms, mailables, errorPages, events, listeners, jobs, policies, providers, seeds, migrations, plugins, config] =
+  const [routes, graphql, rooms, mailables, errorPages, events, listeners, jobs, policies, providers, seeds, migrations, plugins, config, live] =
     await Promise.all([
       collectWithModules(abs, 'routes', /\.(ts|js)$/),
       collectWithModules(abs, 'graphql', /\.graph\.(ts|js)$/),
@@ -90,6 +91,7 @@ export async function discoverBackend(srcRoot: string): Promise<DiscoveryResult>
       collect(join(abs, 'database', 'migrations'), /^\d{4}_\d{2}_\d{2}_\d{6}_.*\.(ts|js)$/),
       collectPluginDirs(join(abs, 'plugins')),
       collect(join(abs, 'config'), /\.(ts|js)$/),
+      collect(join(abs, 'live'), /\.live\.(ts|js)$/),
     ]);
 
   // errors/Handler.ts is a single well-known file.
@@ -98,7 +100,7 @@ export async function discoverBackend(srcRoot: string): Promise<DiscoveryResult>
     ? { path: errorHandlerPath, name: 'Handler', subdir: '' }
     : null;
 
-  return { routes, graphql, rooms, mailables, errorPages, events, listeners, jobs, policies, providers, seeds, migrations, plugins, config, errorHandler };
+  return { routes, graphql, rooms, mailables, errorPages, events, listeners, jobs, policies, providers, seeds, migrations, plugins, config, live, errorHandler };
 }
 
 async function collect(dir: string, pattern: RegExp): Promise<DiscoveredFile[]> {

package/src/app/errorPages.ts

@@ -1,9 +1,9 @@
 /**
  * ErrorPages — renders a templated HTML page for a given HTTP status.
  *
- * Reads `mail/pages/<status>.html` (project-level) if present, else falls back
- * to the framework default template. Substitutes simple {{PLACEHOLDER}}
- * markers. Production-safe (no stack traces).
+ * Reads `errors/pages/<status>.html` (backend src-level) if present, else
+ * falls back to the framework default template. Substitutes simple
+ * {{PLACEHOLDER}} markers. Production-safe (no stack traces).
  */
 import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
@@ -37,7 +37,10 @@ export interface ErrorPageRenderContext {
 }
 
 export class ErrorPages {
-  constructor(private projectRoot: string) {}
+  constructor(
+    private projectRoot: string,
+    private srcRoot?: string,
+  ) {}
 
   /** Render the HTML for a given status. */
   async render(status: number, ctx: ErrorPageRenderContext = {}): Promise<string> {
@@ -59,8 +62,21 @@ export class ErrorPages {
 
   private async tryCustomPage(status: number): Promise<string | null> {
     const candidates = [
+      // Backend src root first — the layout used by real projects
+      // (e.g. apps/backend/src/errors/pages/404.html).
+      ...(this.srcRoot
+        ? [
+            join(this.srcRoot, 'errors', 'pages', `${status}.html`),
+            join(this.srcRoot, 'errors', 'pages', 'error.html'),
+          ]
+        : []),
+      // Project-root fallbacks (legacy + monorepo variants).
       join(this.projectRoot, 'src', 'errors', 'pages', `${status}.html`),
-      join(this.projectRoot, 'src', 'errors', 'pages', 'error.html'),   // generic catch-all
+      join(this.projectRoot, 'src', 'errors', 'pages', 'error.html'),
+      join(this.projectRoot, 'apps', 'backend', 'src', 'errors', 'pages', `${status}.html`),
+      join(this.projectRoot, 'apps', 'backend', 'src', 'errors', 'pages', 'error.html'),
+      join(this.projectRoot, 'errors', 'pages', `${status}.html`),
+      join(this.projectRoot, 'errors', 'pages', 'error.html'), // generic catch-all
     ];
     for (const cand of candidates) {
       if (existsSync(cand)) {

package/src/app/fusionEngine.ts

@@ -0,0 +1,53 @@
+import { mkdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import type { FusionDatabase } from '@bhooai/nexus-fusion';
+import type { NexusConfig } from '../config/types.js';
+import { fusionDir } from '../config/dbAccess.js';
+
+/**
+ * App Fusion engine lifecycle — one engine per backend process, opened at
+ * boot when `db.fusion.enabled` and closed on shutdown.
+ *
+ * `@bhooai/nexus-fusion` is dynamically imported so mongo-only backends never
+ * need the package (or its Rust core) installed.
+ */
+
+let engine: FusionDatabase | null = null;
+
+export async function openAppFusion(projectRoot: string, config: NexusConfig): Promise<FusionDatabase> {
+  if (engine) return engine;
+  let mod: typeof import('@bhooai/nexus-fusion');
+  try {
+    mod = await import('@bhooai/nexus-fusion');
+  } catch {
+    throw new Error(
+      "[db] db.fusion.enabled is true but '@bhooai/nexus-fusion' cannot be loaded — " +
+        'add it as a dependency (file:../path/to/packages/nexus-fusion) and install.',
+    );
+  }
+  const fz = config.db.fusion;
+  const dir = fz.persist ? resolve(projectRoot, fusionDir(config)) : undefined;
+  if (dir) await mkdir(dir, { recursive: true });
+  engine = mod.fusion('main', 'prod', {
+    ...(dir ? { dir } : {}),
+    cacheCapacity: fz.cacheCapacity,
+    cacheTtlMs: fz.cacheTtlMs,
+    walCompactThreshold: fz.walCompactThreshold,
+  });
+  console.log(`[db] fusion engine open (${dir ?? 'in-memory'})`);
+  return engine;
+}
+
+export function getAppFusion(): FusionDatabase {
+  if (!engine) throw new Error('[db] Fusion engine is not open — enable db.fusion first.');
+  return engine;
+}
+
+export async function closeAppFusion(): Promise<void> {
+  if (!engine) return;
+  try {
+    engine.close();
+  } finally {
+    engine = null;
+  }
+}

package/src/app/index.ts

@@ -11,7 +11,10 @@ export * from './Mailable.js';
 export * from './ErrorHandler.js';
 export * from './Seeder.js';
 export * from './Storage.js';
+export * from './Upload.js';
 export * from './maintenance.js';
 export * from './adminModule.js';
 export * from './authModule.js';
 export * from './userModel.js';
+export * from './userStore.js';
+export * from './fusionEngine.js';

package/src/app/preflightModule.ts

@@ -1,5 +1,6 @@
 import { createConnection } from 'node:net';
 import type { Router, NexusConfig } from '../index.js';
+import { mongoEnabled, mongoUri } from '../config/dbAccess.js';
 
 /**
  * Preflight diagnostics — native Node connectivity/latency probes.
@@ -197,6 +198,12 @@ export interface PreflightOptions {
   graphqlMounted?: boolean;
 }
 
+/** Port for a named app from nexus.config.ts `apps[]` (undefined = not declared). */
+function appPort(config: NexusConfig, name: string): number | undefined {
+  const entry = config.apps?.find((a) => a.name === name);
+  return entry && entry.enabled !== false && Number.isFinite(entry.port) ? entry.port : undefined;
+}
+
 /** Register `POST /admin/preflight` (guarded by the caller's /admin middleware). */
 export function registerPreflightRoutes(router: Router, config: NexusConfig, opts: PreflightOptions = {}): void {
   router.post('/admin/preflight', async (ctx) => {
@@ -220,10 +227,12 @@ export function registerPreflightRoutes(router: Router, config: NexusConfig, opt
       targets.push({ name: 'GraphQL', kind: 'http', url: graphqlUrl, timeout: 3000 });
     }
 
-    // Mongo + Redis as TCP reachability probes (authenticated ping is out of scope here).
-    const dbUri = config.db?.uri ?? 'mongodb://127.0.0.1:27017';
-    const mongo = endpointFromUrl(dbUri, 27017);
-    targets.push({ name: 'MongoDB', kind: 'tcp', host: mongo.host, port: mongo.port, timeout: 2000 });
+    // MongoDB as a TCP reachability probe (authenticated ping is out of scope).
+    // Skipped when mongodb is disabled (fusion-active backends).
+    if (mongoEnabled(config)) {
+      const mongo = endpointFromUrl(mongoUri(config), 27017);
+      targets.push({ name: 'MongoDB', kind: 'tcp', host: mongo.host, port: mongo.port, timeout: 2000 });
+    }
 
     const redisUrl = config.redis?.url ?? '';
     if (redisUrl) {
@@ -231,6 +240,34 @@ export function registerPreflightRoutes(router: Router, config: NexusConfig, opt
       targets.push({ name: 'Redis', kind: 'tcp', host: redis.host, port: redis.port, timeout: 2000 });
     }
 
+    // Enabled AI providers — probe reachability of each base URL's host:port.
+    for (const p of config.ai?.providers ?? []) {
+      if (!p.enabled || !p.baseUrl) continue;
+      const ep = endpointFromUrl(p.baseUrl, p.baseUrl.startsWith('https:') ? 443 : 80);
+      targets.push({ name: `AI · ${p.label}`, kind: 'tcp', host: ep.host, port: ep.port, timeout: 2500 });
+    }
+
+    // SMTP relay — only when actually configured for delivery.
+    const smtp = config.email?.smtp;
+    if (config.email?.provider === 'smtp' && smtp?.host && smtp.port) {
+      targets.push({ name: 'Email (SMTP)', kind: 'tcp', host: normalizeProbeHost(smtp.host), port: smtp.port, timeout: 2500 });
+    }
+
+    // Frontend dev server — only when enabled in this stack.
+    if (config.frontend?.enabled) {
+      targets.push({ name: 'Frontend', kind: 'http', url: `http://${host}:${config.frontend.port}`, timeout: 2500 });
+    }
+
+    // Fusion DB server + Python pyserver — declared in nexus.config.ts `apps[]`.
+    const fusionPort = appPort(config, 'fusion');
+    if (fusionPort) {
+      targets.push({ name: 'Fusion DB', kind: 'http', url: `http://127.0.0.1:${fusionPort}/health`, timeout: 2500 });
+    }
+    const pyPort = appPort(config, 'pyserver');
+    if (pyPort) {
+      targets.push({ name: 'PyServer', kind: 'http', url: `http://127.0.0.1:${pyPort}/health`, timeout: 2500 });
+    }
+
     const runner = async (t: PreflightTarget): Promise<PreflightCheck> => {
       if (t.kind === 'http') {
         return httpProbe(t.url ?? '', t.timeout ?? 3000).then((c) => ({ ...c, name: t.name }));