@lenne.tech/nest-server 12.0.0 → 12.1.0

package/src/core/modules/file/file-metadata.store.ts

@@ -0,0 +1,109 @@
+import type { Connection } from 'mongoose';
+
+import { isObjectIdLike } from '../../common/helpers/id.helper.js';
+import type { DataStore, FindOptions } from '../../common/persistence/data-store.interface.js';
+import { getRegisteredDataStore, getStoreForModel } from '../../common/persistence/persistence-runtime.registry.js';
+import { UnsupportedCapabilityError } from '../../common/persistence/unsupported-capability.error.js';
+import type { FileCollection } from './file-metadata.helper.js';
+import { FILESYSTEM_FILE_MODEL, S3_FILE_MODEL } from './file-metadata.models.js';
+import { FILESYSTEM_FILES_COLLECTION } from './filesystem-file.helper.js';
+import { S3_FILES_COLLECTION } from './s3-file.helper.js';
+import { newObjectId } from '../../common/persistence/mongo/mongoose-compat.js';
+
+/** The two stores that keep their metadata outside GridFS */
+export type FileMetadataStore = 'filesystem' | 's3';
+
+const STORES: Record<FileMetadataStore, { collection: string; model: string }> = {
+  filesystem: { collection: FILESYSTEM_FILES_COLLECTION, model: FILESYSTEM_FILE_MODEL },
+  s3: { collection: S3_FILES_COLLECTION, model: S3_FILE_MODEL },
+};
+
+/**
+ * Where the metadata of a store lives: its MongoDB collection, or — when `database` routes the model to a SQL source —
+ * that model's table, behind the same few collection operations the file helpers use. Resolved per call, so a
+ * service constructed before the stores exist still reaches the right one.
+ *
+ * Every reader and writer of `s3-files` / `filesystem-files` goes through here (`CoreFileService`, the TUS hand-off,
+ * the Hub): one of them reading the collection while the others write the table would lose files from view.
+ */
+export function fileMetadataCollection(connection: Connection | null, store: FileMetadataStore): FileCollection {
+  const { collection, model } = STORES[store];
+  const dataStore = connection
+    ? connection.models?.[model]
+      ? getStoreForModel(connection.models[model])
+      : undefined
+    : // No MongoDB connection (PostgreSQL alone, or `database: false`): the store registered for the model is the only
+      // one there is — this application's, since no other can have one without a connection either
+      getRegisteredDataStore(model);
+  if (dataStore && !dataStore.capabilities.mongoosePopulate) {
+    return sqlFileCollection(dataStore, collection);
+  }
+  if (!connection) {
+    throw new UnsupportedCapabilityError(
+      `The ${collection} file metadata has nowhere to go: no MongoDB is configured and no data source routes ${model}`,
+    );
+  }
+  return connection.db.collection(collection);
+}
+
+/**
+ * A metadata table seen as the collection the helpers expect: `_id` (an ObjectId) is the record's `id`, MongoDB
+ * filters and sorts are passed to the store with `_id` renamed, and a record comes back with `_id` as an ObjectId and
+ * without the columns it has no value in — the shape a document of the collection has.
+ */
+export function sqlFileCollection(store: DataStore<any>, collectionName: string): FileCollection {
+  const find = async (filter: unknown, options: Record<string, any> = {}) =>
+    (await store.find(toWhere(filter ?? {}), toFindOptions(options))).map(toDocument);
+  const collection = {
+    collectionName,
+    countDocuments: async (filter: unknown = {}) => store.count(toWhere(filter)),
+    // The table carries the `filename` index the model declares
+    createIndex: async () => 'filename_1',
+    dbName: 'sql',
+    deleteOne: async (filter: unknown) => ({
+      acknowledged: true,
+      deletedCount: (await store.deleteOne(toWhere(filter))) ? 1 : 0,
+    }),
+    find: (filter?: unknown, options?: Record<string, any>) => ({ toArray: () => find(filter, options) }),
+    findOne: async (filter?: unknown, options?: Record<string, any>) =>
+      (await find(filter, { ...options, limit: 1 }))[0] ?? null,
+    insertOne: async (doc: Record<string, any>) => {
+      const { _id, ...fields } = doc;
+      await store.insert({ ...fields, id: String(_id) });
+      return { acknowledged: true, insertedId: _id };
+    },
+  };
+  return collection as unknown as FileCollection;
+}
+
+/** A MongoDB filter for the store: `_id` becomes `id`, ObjectIds become their hex strings — at every depth */
+function toWhere(value: unknown): any {
+  if (isObjectIdLike(value)) {
+    return value.toHexString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(toWhere);
+  }
+  if (!value || typeof value !== 'object' || value instanceof Date || value instanceof RegExp) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key === '_id' ? 'id' : key, toWhere(entry)]));
+}
+
+function toFindOptions(options: Record<string, any>): FindOptions {
+  const { collation, limit, skip, sort } = options;
+  return {
+    ...(collation ? { collation } : {}),
+    ...(limit ? { limit } : {}),
+    ...(skip ? { skip } : {}),
+    ...(sort ? { sort: toWhere(sort) } : {}),
+  };
+}
+
+function toDocument(record: Record<string, any>): Record<string, any> {
+  const { id, ...fields } = record;
+  return {
+    _id: newObjectId(id),
+    ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== null && value !== undefined)),
+  };
+}

package/src/core/modules/file/file-storage.helper.ts

@@ -1,6 +1,8 @@
 import { Logger } from '@nestjs/common';
 
 import { IServerOptions } from '../../common/interfaces/server-options.interface.js';
+import { resolveDataSources, resolveModelSource } from '../../common/persistence/data-source.config.js';
+import { FILESYSTEM_FILE_MODEL } from './file-metadata.models.js';
 
 const logger = new Logger('CoreFileStorage');
 
@@ -58,6 +60,28 @@ export function hasDatabaseConfig(config?: Partial<IServerOptions>): boolean {
   return !!config?.mongoose?.uri;
 }
 
+/**
+ * The SQL data source `database` routes the file metadata to, or `undefined` when it stays on MongoDB. Answers from the
+ * configuration alone, so the driver is known before any store exists; a configuration that cannot be resolved has
+ * already stopped the boot in `CoreModule.forRoot()`, so it reads as "MongoDB" here.
+ */
+export function fileMetadataSqlSource(config?: Partial<IServerOptions>): string | undefined {
+  if (!config?.database) {
+    return undefined;
+  }
+  try {
+    const resolved = resolveDataSources({
+      database: config.database,
+      explicitMongoose: !!config.mongoose,
+      mongooseUri: config.mongoose?.uri,
+    });
+    const source = resolveModelSource(resolved, FILESYSTEM_FILE_MODEL);
+    return source && resolved.sources[source]?.driver !== 'mongodb' ? source : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Decide which storage driver to use.
  *
@@ -69,8 +93,10 @@ export function hasDatabaseConfig(config?: Partial<IServerOptions>): boolean {
  * Without an explicit value the default is derived, most capable first:
  *
  *   1. `s3`         — when the S3 config names a bucket
- *   2. `gridfs`     — when a database is configured
- *   3. `filesystem` — when neither is (today a theoretical case: `CoreModule`
+ *   2. `filesystem` — when `database` routes the file metadata to a SQL source:
+ *                     GridFS would put bytes and metadata into MongoDB
+ *   3. `gridfs`     — when a database is configured
+ *   4. `filesystem` — when none is (today a theoretical case: `CoreModule`
  *                     always registers Mongoose, so a project without a database
  *                     does not boot at all)
  *
@@ -97,6 +123,25 @@ export function resolveFileStorage(config?: Partial<IServerOptions>): FileStorag
     return { driver: 's3', explicit: false, reason: 's3.bucket is configured' };
   }
 
+  if (config?.database === false) {
+    return {
+      driver: 'filesystem',
+      explicit: false,
+      reason: 'the project runs without a database (`database: false`) — file metadata has nowhere to go',
+    };
+  }
+
+  const sqlSource = fileMetadataSqlSource(config);
+  if (sqlSource) {
+    // GridFS keeps bytes AND metadata in MongoDB; a project that routes the file metadata to SQL does not get its
+    // files put into MongoDB without asking for it (`file.storage: 'gridfs'` still does)
+    return {
+      driver: 'filesystem',
+      explicit: false,
+      reason: `no S3 bucket is configured and the file metadata lives in the SQL source "${sqlSource}"`,
+    };
+  }
+
   if (hasDatabaseConfig(config)) {
     return { driver: 'gridfs', explicit: false, reason: 'a database is configured and no S3 bucket is' };
   }

package/src/core/modules/file/filesystem-file.helper.ts

@@ -1,6 +1,6 @@
 import { createReadStream, createWriteStream } from 'fs';
 import { mkdir, rm, stat } from 'fs/promises';
-import { Types } from 'mongoose';
+import type { Types } from 'mongoose';
 import * as path from 'path';
 import { pipeline } from 'stream/promises';
 import { Readable } from 'stream';
@@ -14,8 +14,9 @@ import {
   findMetadataByName,
 } from './file-metadata.helper.js';
 import { streamToBuffer } from './s3-file.helper.js';
+import { newObjectId } from '../../common/persistence/mongo/mongoose-compat.js';
 
-/** Metadata collection for files stored on the local filesystem */
+/** Metadata collection for files stored on the local filesystem (on a SQL source: the table `filesystem_files`) */
 export const FILESYSTEM_FILES_COLLECTION = 'filesystem-files';
 
 /** Default directory for the filesystem storage driver */
@@ -31,12 +32,14 @@ export const DEFAULT_FILESYSTEM_DIR = 'uploads/files';
 export type FilesystemFileInfo = FileMetadataInfo;
 
 /**
- * Helper for files stored on the local filesystem with their metadata in MongoDB.
+ * Helper for files stored on the local filesystem with their metadata in the database.
  *
  * Counterpart of `GridFSHelper` and `S3FileHelper`: same operations, the local
- * disk as the byte store and `filesystem-files` as the metadata store.
+ * disk as the byte store and `filesystem-files` as the metadata store — pass
+ * `fileMetadataCollection(connection, 'filesystem')`, never the MongoDB collection
+ * directly: on a SQL source the metadata lives in the table `filesystem_files`.
  *
- * WHY THE METADATA STILL LIVES IN MONGO: filename, content type, length and the
+ * WHY THE METADATA STILL LIVES IN THE DATABASE: filename, content type, length and the
  * custom `metadata` a per-file authorization rule reads have to be queryable —
  * `findFileInfo()` filters and pages over them, and `checkRights()` reads them
  * per request. A directory listing answers none of that, and sidecar files would
@@ -57,7 +60,7 @@ export class FilesystemFileHelper {
    * a user-supplied filename here.
    */
   static filePath(directory: string, id: string | Types.ObjectId): string {
-    const objectId = typeof id === 'string' ? new Types.ObjectId(id) : id;
+    const objectId = typeof id === 'string' ? newObjectId(id) : id;
     return path.join(path.resolve(directory), objectId.toHexString());
   }
 
@@ -83,7 +86,7 @@ export class FilesystemFileHelper {
       metadata?: Record<string, any>;
     },
   ): Promise<FilesystemFileInfo> {
-    const _id = new Types.ObjectId();
+    const _id = newObjectId();
     const target = FilesystemFileHelper.filePath(directory, _id);
 
     await mkdir(path.dirname(target), { recursive: true });
@@ -163,7 +166,7 @@ export class FilesystemFileHelper {
    * up through the API.
    */
   static async deleteFile(directory: string, collection: FileCollection, id: string | Types.ObjectId): Promise<void> {
-    const objectId = typeof id === 'string' ? new Types.ObjectId(id) : id;
+    const objectId = typeof id === 'string' ? newObjectId(id) : id;
     await rm(FilesystemFileHelper.filePath(directory, objectId), { force: true });
     await collection.deleteOne({ _id: objectId });
   }

package/src/core/modules/file/s3-file.helper.ts

@@ -1,4 +1,4 @@
-import { Types } from 'mongoose';
+import type { Types } from 'mongoose';
 import { Readable } from 'stream';
 
 import { CoreS3Service } from '../../common/services/core-s3.service.js';
@@ -10,13 +10,15 @@ import {
   findMetadataById,
   findMetadataByName,
 } from './file-metadata.helper.js';
+import { newObjectId } from '../../common/persistence/mongo/mongoose-compat.js';
 
 /**
  * Name of the MongoDB collection holding the metadata of S3-stored files.
  *
  * S3 itself has no queryable metadata store, so file info (filename, contentType,
  * length, uploadDate) is kept in this collection — the equivalent of GridFS's
- * `fs.files`. The object key in the bucket is the string form of `_id`.
+ * `fs.files`. The object key in the bucket is the string form of `_id`. On a SQL
+ * source the same records live in the table `s3_files` (`fileMetadataCollection()`).
  */
 export const S3_FILES_COLLECTION = 's3-files';
 
@@ -56,7 +58,9 @@ export async function streamToBuffer(stream: Readable): Promise<Buffer> {
 }
 
 /**
- * Helper for files stored in S3 with their metadata in MongoDB.
+ * Helper for files stored in S3 with their metadata in the database — pass
+ * `fileMetadataCollection(connection, 's3')` as the collection: on a SQL source the
+ * metadata lives in the table `s3_files`, not in MongoDB.
  *
  * Counterpart of GridFSHelper: same operations, S3 as the byte store and
  * `s3-files` as the metadata store.
@@ -81,7 +85,7 @@ export class S3FileHelper {
       metadata?: Record<string, any>;
     },
   ): Promise<S3FileInfo> {
-    const _id = new Types.ObjectId();
+    const _id = newObjectId();
     const key = _id.toHexString();
 
     // A stream is never read into a Buffer here. Doing so — which every caller used to do —
@@ -126,7 +130,7 @@ export class S3FileHelper {
       sourceKey: string;
     },
   ): Promise<S3FileInfo> {
-    const _id = new Types.ObjectId();
+    const _id = newObjectId();
     await s3Service.copyObject(options.sourceKey, _id.toHexString(), options.sourceBucket, options.contentType);
 
     return S3FileHelper.recordFile(s3Service, collection, _id, {
@@ -206,7 +210,7 @@ export class S3FileHelper {
     collection: FileCollection,
     id: string | Types.ObjectId,
   ): Promise<void> {
-    const objectId = typeof id === 'string' ? new Types.ObjectId(id) : id;
+    const objectId = typeof id === 'string' ? newObjectId(id) : id;
     await s3Service.deleteObject(objectId.toHexString());
     await collection.deleteOne({ _id: objectId });
   }
@@ -215,7 +219,7 @@ export class S3FileHelper {
    * Get the download stream of a file
    */
   static async getStream(s3Service: CoreS3Service, id: string | Types.ObjectId): Promise<Readable> {
-    const objectId = typeof id === 'string' ? new Types.ObjectId(id) : id;
+    const objectId = typeof id === 'string' ? newObjectId(id) : id;
     return (await s3Service.getObject(objectId.toHexString())).body;
   }
 

package/src/core/modules/health-check/core-health-check.module.ts

@@ -1,5 +1,8 @@
 import { Module } from '@nestjs/common';
-import { TerminusModule } from '@nestjs/terminus';
+import { ModuleRef } from '@nestjs/core';
+import { HealthIndicatorService, MongooseHealthIndicator, TerminusModule } from '@nestjs/terminus';
+
+import { getConnectionToken } from '../../common/persistence/mongo/mongoose-compat.js';
 
 import { CoreHealthCheckController } from './core-health-check.controller.js';
 import { CoreHealthCheckResolver } from './core-health-check.resolver.js';
@@ -12,6 +15,17 @@ import { CoreHealthCheckService } from './core-health-check.service.js';
 @Module({
   controllers: [CoreHealthCheckController],
   imports: [TerminusModule],
-  providers: [CoreHealthCheckService, CoreHealthCheckResolver],
+  providers: [
+    CoreHealthCheckService,
+    CoreHealthCheckResolver,
+    {
+      inject: [ModuleRef, HealthIndicatorService, { optional: true, token: getConnectionToken() }],
+      provide: MongooseHealthIndicator,
+      // Terminus' indicator requires Mongoose as it is constructed. Without a MongoDB connection (a project on
+      // PostgreSQL alone) there is nothing for it to ping, and no Mongoose to require: the service skips the ping
+      useFactory: (moduleRef: ModuleRef, indicators: HealthIndicatorService, connection?: unknown) =>
+        connection ? new MongooseHealthIndicator(moduleRef, indicators) : null,
+    },
+  ],
 })
 export class CoreHealthCheckModule {}

package/src/core/modules/health-check/core-health-check.service.ts

@@ -1,15 +1,17 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable, Optional } from '@nestjs/common';
 import {
   DiskHealthIndicator,
   type DiskHealthIndicatorOptions,
   HealthCheckResult,
   HealthCheckService,
+  HealthIndicatorService,
   MemoryHealthIndicator,
   MongooseHealthIndicator,
   type MongoosePingCheckSettings,
 } from '@nestjs/terminus';
 
 import { getBuildInfo } from '../../common/helpers/meta.helper.js';
+import { getPersistenceRuntime } from '../../common/persistence/persistence-runtime.registry.js';
 import { ConfigService } from '../../common/services/config.service.js';
 
 /**
@@ -20,15 +22,18 @@ import { ConfigService } from '../../common/services/config.service.js';
 export class CoreHealthCheckService {
   constructor(
     protected config: ConfigService,
-    protected db: MongooseHealthIndicator,
+    // Explicit token: a union type gives Nest no class to inject; `null` where no MongoDB is configured (module factory)
+    @Inject(MongooseHealthIndicator) protected db: MongooseHealthIndicator | null,
     protected disk: DiskHealthIndicator,
     protected health: HealthCheckService,
     protected memory: MemoryHealthIndicator,
+    @Optional() protected indicators?: HealthIndicatorService,
   ) {}
 
   healthCheck(): Promise<HealthCheckResult> {
     const healthIndicatorFunctions = [];
-    if (this.config.get<boolean>('healthCheck.configs.database.enabled')) {
+    // The MongoDB ping where MongoDB is configured — a project on PostgreSQL alone has no MongoDB to ping
+    if (this.db && this.config.get<boolean>('healthCheck.configs.database.enabled')) {
       healthIndicatorFunctions.push(() => {
         // `timeout` stays part of the config contract, but @nestjs/terminus 12 deprecated it on the
         // indicator in favour of `.withTimeout()` on the returned attempt — translate it here, so the
@@ -45,6 +50,23 @@ export class CoreHealthCheckService {
         return timeout === undefined ? attempt : attempt.withTimeout(timeout);
       });
     }
+    if (this.config.get<boolean>('healthCheck.configs.database.enabled')) {
+      // Every SQL source answers on its own key, next to the MongoDB ping: `<key>:<source>` (`database:default`). A
+      // database the application cannot reach is down, whichever one it is
+      const key = this.config.get<string>('healthCheck.configs.database.key') ?? 'database';
+      const timeout =
+        this.config.get<MongoosePingCheckSettings>('healthCheck.configs.database.options')?.timeout ?? 1000;
+      for (const source of getPersistenceRuntime()?.sqlSources() ?? []) {
+        if (this.indicators) {
+          healthIndicatorFunctions.push(() =>
+            this.indicators
+              .check(`${key}:${source.name}`)
+              .attempt(() => source.ping())
+              .withTimeout(timeout),
+          );
+        }
+      }
+    }
     if (this.config.get<boolean>('healthCheck.configs.memoryHeap.enabled')) {
       healthIndicatorFunctions.push(() =>
         this.memory.checkHeap(

package/src/core/modules/hub/README.md

@@ -33,11 +33,12 @@ Do NOT set `hub` in the `production` block unless you intend the cockpit to be r
 | Diagnostics          | `/hub/diagnostics`    | heap/rss, node/platform, collector buffer levels                |
 | Logs                 | `/hub/logs`           | in-memory log ring buffer (redacted)                            |
 | Request Traces       | `/hub/traces`         | HTTP timing middleware                                          |
-| Query Performance    | `/hub/queries`        | MongoDB driver command monitoring (opt-in)                      |
+| Query Performance    | `/hub/queries`        | MongoDB driver command monitoring (opt-in; MongoDB only)        |
 | Cron Jobs            | `/hub/cron`           | `@nestjs/schedule` `SchedulerRegistry` (optional)               |
-| Database             | `/hub/db`             | dbStats / per-collection collStats                              |
+| Database             | `/hub/db`             | dbStats / per-collection collStats (MongoDB only)               |
 | Models / ERD         | `/hub/models`         | Mongoose schemas → Mermaid ER diagram                           |
-| Migrations           | `/hub/migrations`     | `MigrationRunner` status + run/rollback                         |
+| Persistence          | `/hub/persistence`    | data sources, and per model: source, database, capabilities     |
+| Migrations           | `/hub/migrations`     | `MigrationRunner` status + run/rollback (MongoDB or SQL state)  |
 | Files                | `/hub/files`          | listing + delete across all three storage drivers               |
 | Config               | `/hub/config`         | full config, secrets masked                                     |
 | Auth Migration       | `/hub/auth-migration` | Legacy → IAM progress (BetterAuth, optional)                    |
@@ -50,17 +51,25 @@ Do NOT set `hub` in the `production` block unless you intend the cockpit to be r
 Each panel has a `*.json` sidecar (the stable data contract) that the client polls. Optional sources
 degrade to an "unavailable" state instead of erroring.
 
+With a SQL data source (`database`, see `.claude/rules/configurable-features.md` → Data Sources) the Database and
+Query Performance panels cover the MongoDB connection only and report "unavailable" without one. The Migrations panel
+reads the state from the store the framework keeps for the default source: on a SQL default source the
+`lt_migrations` table, through the owner connection (`database.ownerUrl`, required there). That presumes
+`migrations-utils/migrate.js` passes `database.ownerUrl` to `createMigrationStore()` (see the migrate README). While
+it still passes the MongoDB URI, the table stays empty and the MongoDB collection lists the applied migrations; the
+panel then reports that conflict and refuses Run and Rollback, which would apply the migrations a second time.
+
 ### Files panel
 
 The panel reads all three file metadata stores, not just GridFS — the same three
-`CoreFileService.findFileInfo()` consults, because metadata always lives in MongoDB whichever store
-holds the bytes:
-
-| Store        | Collection                            | Bytes live in                   |
-| ------------ | ------------------------------------- | ------------------------------- |
-| `s3`         | `s3-files`                            | the S3 bucket                   |
-| `filesystem` | `filesystem-files`                    | `file.storageDir` on local disk |
-| `gridfs`     | `<bucket>.files` (default `fs.files`) | MongoDB                         |
+`CoreFileService.findFileInfo()` consults, wherever `database` routes their metadata
+(`fileMetadataCollection()`):
+
+| Store        | Metadata                                                | Bytes live in                   |
+| ------------ | ------------------------------------------------------- | ------------------------------- |
+| `s3`         | collection `s3-files`, on a SQL source table `s3_files` | the S3 bucket                   |
+| `filesystem` | `filesystem-files`, on a SQL source `filesystem_files`  | `file.storageDir` on local disk |
+| `gridfs`     | `<bucket>.files` (default `fs.files`), always MongoDB   | MongoDB                         |
 
 Every row carries the `store` it was found in, and `files.json` reports a per-store `count` so an
 empty store reads as **empty** rather than as _"this panel does not cover your driver"_. Until

package/src/core/modules/hub/core-hub.controller.ts

@@ -156,6 +156,11 @@ export class CoreHubController {
     this.sendJson(res, this.dbService.getModels());
   }
 
+  @Get('persistence.json')
+  persistenceJson(@Res() res: Response): void {
+    this.sendJson(res, this.sourcesService.getPersistence());
+  }
+
   /**
    * ADMIN-gated auth probe AND cockpit-chrome payload: 200 returns the navigation, environment badge,
    * version and external links the client uses to build the layout; 401/403 keeps the shell showing

package/src/core/modules/hub/core-hub.service.ts

@@ -1,5 +1,5 @@
 import { Inject, Injectable, Optional } from '@nestjs/common';
-import { InjectConnection } from '@nestjs/mongoose';
+import { InjectConnection } from '../../common/persistence/mongo/mongoose-compat.js';
 import type { Connection } from 'mongoose';
 
 import { getBuildInfo } from '../../common/helpers/meta.helper.js';

package/src/core/modules/hub/helpers/hub-client-js.helper.ts

@@ -479,6 +479,29 @@ export function getHubClientJs(): string {
     }, function (e) { clear(content); content.appendChild(unavailable('Failed to load: ' + e.message)); });
   };
 
+  Hub.panels.persistence = function (content) {
+    // Routing is fixed at boot; load once instead of polling.
+    hubFetch('/persistence.json').then(function (d) {
+      clear(content);
+      if (d && d.available === false) { content.appendChild(unavailable(d.hint)); return; }
+      content.appendChild(el('h3', { text: 'Data sources' }));
+      content.appendChild(table([
+        { key: 'name', label: 'Source', render: function (r) { return r.name + (r.name === d.defaultSource ? ' (default)' : ''); } },
+        { key: 'driver', label: 'Database' },
+        { key: 'engine', label: 'Engine', render: function (r) { return r.engine || '–'; } },
+        { key: 'host', label: 'Host' },
+        { key: 'ownerConfigured', label: 'Owner role', render: function (r) { return r.driver === 'mongodb' ? '–' : (r.ownerConfigured ? 'configured' : 'verify only'); } },
+      ], d.sources || []));
+      content.appendChild(el('h3', { text: 'Models (' + (d.models || []).length + ')' }));
+      content.appendChild(table([
+        { key: 'name', label: 'Model' },
+        { key: 'source', label: 'Source', render: function (r) { return r.source || '–'; } },
+        { key: 'driver', label: 'Store', render: function (r) { return r.driver || 'not created yet'; } },
+        { key: 'capabilities', label: 'Capabilities', render: function (r) { return (r.capabilities || []).join(', ') || '–'; } },
+      ], d.models || []));
+    }, function (e) { clear(content); content.appendChild(unavailable('Failed to load: ' + e.message)); });
+  };
+
   Hub.panels.config = function (content) {
     hubFetch('/config.json').then(function (d) { clear(content); content.appendChild(el('p', { class: 'hub-hint', text: 'Secrets are masked.' })); content.appendChild(jsonView(d)); },
       function (e) { clear(content); content.appendChild(unavailable('Failed to load: ' + e.message)); });

package/src/core/modules/hub/hub-action-messages.ts

@@ -39,6 +39,12 @@ export const HubActionMessage = {
   missingHubRequestHeader: 'Missing X-Hub-Request header.',
   /** Any action that needs the Mongo connection while it is unavailable. */
   mongoUnavailable: 'No MongoDB connection is available.',
+  /** Migrations on a SQL default source run as the table owner. */
+  sqlOwnerMissing:
+    'The migration state of a SQL default source is read and written as the table owner — configure database.ownerUrl.',
+  /** SQL default source with an empty `lt_migrations` while the MongoDB collection lists applied migrations. */
+  migrationStateInMongo: (collection: string) =>
+    `The default source is a SQL database, but its lt_migrations table is empty while the MongoDB collection "${collection}" lists applied migrations — migrations-utils/migrate.js still keeps the state in MongoDB. Pass database.ownerUrl to createMigrationStore() and move the state to the table; until then the Hub neither shows nor runs migrations, which would apply them again.`,
   /** Migrations action while no Mongo URI is configured. */
   mongoUriMissing: 'No MongoDB URI is configured.',
   /** Test mail: no recipient supplied. */

package/src/core/modules/hub/hub-nav.ts

@@ -32,6 +32,7 @@ export const HUB_PANELS: readonly HubPanel[] = [
   { group: 'Runtime', id: 'cron', json: 'cron.json', optional: true, path: 'cron', title: 'Cron Jobs' },
   { group: 'Data', id: 'db', json: 'db.json', path: 'db', title: 'Database' },
   { group: 'Data', id: 'models', json: 'models.json', path: 'models', title: 'Models / ERD' },
+  { group: 'Data', id: 'persistence', json: 'persistence.json', path: 'persistence', title: 'Persistence' },
   { group: 'Data', id: 'migrations', json: 'migrations.json', path: 'migrations', title: 'Migrations' },
   { group: 'Data', id: 'files', json: 'files.json', path: 'files', title: 'Files' },
   { group: 'Data', id: 'config', json: 'config.json', path: 'config', title: 'Config' },

package/src/core/modules/hub/interfaces/hub-panels.interface.ts

@@ -71,12 +71,19 @@ export interface HubModelsData {
   relationCount: number;
 }
 
+/** Persistence panel: where each model is stored, on which database and engine, with which capabilities */
+export interface HubPersistenceData {
+  defaultSource?: string;
+  models: { capabilities: string[]; driver?: string; name: string; source?: string }[];
+  sources: { driver: string; engine?: string; host: string; name: string; ownerConfigured: boolean }[];
+}
+
 export interface HubMigrationsData {
   completed: string[];
   dirAvailable: boolean;
   lastRun?: string;
   pending: string[];
-  source: 'collection' | 'runner';
+  source: 'collection' | 'runner' | 'table';
 }
 
 /**