@lenne.tech/nest-server 11.43.3 → 12.1.0

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

@@ -1,4 +1,5 @@
-import { mongo, Types } from 'mongoose';
+import type { mongo, Types } from 'mongoose';
+import { newObjectId } from '../../common/persistence/mongo/mongoose-compat.js';
 
 /**
  * The metadata shape every non-GridFS storage driver writes, and the queries against it.
@@ -25,7 +26,10 @@ import { mongo, Types } from 'mongoose';
  * `.claude/rules/architecture.md` → "DI Token Placement (SWC-Safe)".
  */
 
-/** Metadata collection handle (no Mongoose schema — these collections are driver-managed) */
+/**
+ * Metadata collection handle — the MongoDB collection, or its table on a SQL source behind the same operations
+ * (`fileMetadataCollection()` decides which)
+ */
 export type FileCollection = mongo.Collection<any>;
 
 /**
@@ -70,7 +74,7 @@ export async function findMetadataById(
   collection: FileCollection,
   id: string | Types.ObjectId,
 ): Promise<FileMetadataInfo | null> {
-  return (await collection.findOne({ _id: new Types.ObjectId(id) })) as FileMetadataInfo | null;
+  return (await collection.findOne({ _id: newObjectId(id) })) as FileMetadataInfo | null;
 }
 
 /**

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

@@ -0,0 +1,44 @@
+import type { Schema } from 'mongoose';
+
+import { createSchema } from '../../common/persistence/mongo/mongoose-compat.js';
+
+import { FILESYSTEM_FILES_COLLECTION } from './filesystem-file.helper.js';
+import { S3_FILES_COLLECTION } from './s3-file.helper.js';
+
+/**
+ * The metadata of files whose bytes live in S3 or on the filesystem, as models — what routes them with `database`
+ * like every other model (db-agnostic phase 4). On a SQL default source the rows live in the tables `s3_files` and
+ * `filesystem_files`; on MongoDB the file helpers keep reading and writing the collections natively, as before.
+ *
+ * `autoCreate` and `autoIndex` are off: these schemas only register the models. A deployment that never writes to a
+ * store must not grow an empty collection for it (`ensureFilenameIndex()` creates the index on the first write), and
+ * nothing may create an index next to the one the helpers ensure. GridFS has no model here: its `fs.files` belongs to
+ * the driver and stays on MongoDB.
+ */
+
+/** Model of the `s3-files` metadata */
+export const S3_FILE_MODEL = 'CoreS3File';
+
+/** Model of the `filesystem-files` metadata */
+export const FILESYSTEM_FILE_MODEL = 'CoreFilesystemFile';
+
+/** The shape both stores write — a GridFS `fs.files` document plus the `storage` marker (`FileMetadataInfo`) */
+function fileMetadataSchema(collection: string): Schema {
+  return createSchema(
+    {
+      contentType: { type: String },
+      filename: { index: true, type: String },
+      length: { type: Number },
+      metadata: { type: Object },
+      storage: { type: String },
+      uploadDate: { type: Date },
+    },
+    { autoCreate: false, autoIndex: false, collection, versionKey: false },
+  );
+}
+
+/** Registered by `CoreModule` through `CorePersistenceModule.forFeature()` */
+export const FILE_METADATA_MODELS = [
+  { name: S3_FILE_MODEL, schema: fileMetadataSchema(S3_FILES_COLLECTION) },
+  { name: FILESYSTEM_FILE_MODEL, schema: fileMetadataSchema(FILESYSTEM_FILES_COLLECTION) },
+];

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-roles.config.ts

@@ -17,8 +17,8 @@
  */
 import { Logger } from '@nestjs/common';
 
-import { RoleEnum } from '../../common/enums/role.enum';
-import { IFileConfig, IS3Config } from '../../common/interfaces/server-options.interface';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { IFileConfig, IS3Config } from '../../common/interfaces/server-options.interface.js';
 
 const logger = new Logger('CoreFileRoles');
 

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

@@ -1,9 +1,9 @@
 import { Logger } from '@nestjs/common';
 
-import { IFileConfig } from '../../common/interfaces/server-options.interface';
-import { CoreFileController } from './core-file.controller';
-import { CoreFileResolver } from './core-file.resolver';
-import { FILE_ROLE_MEMBERS, FileEndpointClassName, FileRoleKey, resolveRoles } from './file-roles.config';
+import { IFileConfig } from '../../common/interfaces/server-options.interface.js';
+import { CoreFileController } from './core-file.controller.js';
+import { CoreFileResolver } from './core-file.resolver.js';
+import { FILE_ROLE_MEMBERS, FileEndpointClassName, FileRoleKey, resolveRoles } from './file-roles.config.js';
 
 const logger = new Logger('CoreFileRoles');
 
@@ -17,8 +17,8 @@ export {
   warnOnPresignedDownloadsWithRestrictedRoles,
   warnOnUndecidedEffectiveFileAccess,
   warnOnUndecidedFileAccess,
-} from './file-roles.config';
-export type { FileEndpointClassName, FileRoleKey, ObservedFileHandler } from './file-roles.config';
+} from './file-roles.config.js';
+export type { FileEndpointClassName, FileRoleKey, ObservedFileHandler } from './file-roles.config.js';
 
 /**
  * The prototypes the member names in {@link FILE_ROLE_MEMBERS} resolve against.

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';
+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';
@@ -12,10 +12,11 @@ import {
   findMetadata,
   findMetadataById,
   findMetadataByName,
-} from './file-metadata.helper';
-import { streamToBuffer } from './s3-file.helper';
+} 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/interfaces/file-upload.interface.ts

@@ -49,7 +49,7 @@ export interface FileUpload extends FileUploadSource {
    */
   createReadStream: (options?: {
     /** Specify an encoding for the chunks, default: utf8 */
-    encoding?: 'ascii' | 'base64' | 'base64url' | 'hex' | 'latin1' | 'ucs2' | 'utf8' | 'utf8' | 'utf16le';
+    encoding?: 'ascii' | 'base64' | 'base64url' | 'hex' | 'latin1' | 'ucs2' | 'utf8' | 'utf16le';
 
     /**  Maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource, default: 16384 */
     highWaterMark?: number;

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

@@ -1,7 +1,7 @@
-import { Types } from 'mongoose';
+import type { Types } from 'mongoose';
 import { Readable } from 'stream';
 
-import { CoreS3Service } from '../../common/services/core-s3.service';
+import { CoreS3Service } from '../../common/services/core-s3.service.js';
 import {
   ensureFilenameIndex,
   FileCollection,
@@ -9,14 +9,16 @@ import {
   findMetadata,
   findMetadataById,
   findMetadataByName,
-} from './file-metadata.helper';
+} 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-result.model.ts

@@ -1,10 +1,10 @@
 import { ObjectType } from '@nestjs/graphql';
 
-import { Restricted } from '../../common/decorators/restricted.decorator';
-import { UnifiedField } from '../../common/decorators/unified-field.decorator';
-import { RoleEnum } from '../../common/enums/role.enum';
-import { CoreModel } from '../../common/models/core-model.model';
-import { JSON } from '../../common/scalars/json.scalar';
+import { Restricted } from '../../common/decorators/restricted.decorator.js';
+import { UnifiedField } from '../../common/decorators/unified-field.decorator.js';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { CoreModel } from '../../common/models/core-model.model.js';
+import { JSON } from '../../common/scalars/json.scalar.js';
 
 /**
  * User model

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

@@ -1,8 +1,8 @@
 import { Controller, Get } from '@nestjs/common';
 
-import { Roles } from '../../common/decorators/roles.decorator';
-import { RoleEnum } from '../../common/enums/role.enum';
-import { CoreHealthCheckService } from './core-health-check.service';
+import { Roles } from '../../common/decorators/roles.decorator.js';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { CoreHealthCheckService } from './core-health-check.service.js';
 
 /**
  * The HealthController class checks the health of various components including the database, memory, and disk.

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

@@ -1,9 +1,12 @@
 import { Module } from '@nestjs/common';
-import { TerminusModule } from '@nestjs/terminus';
+import { ModuleRef } from '@nestjs/core';
+import { HealthIndicatorService, MongooseHealthIndicator, TerminusModule } from '@nestjs/terminus';
 
-import { CoreHealthCheckController } from './core-health-check.controller';
-import { CoreHealthCheckResolver } from './core-health-check.resolver';
-import { CoreHealthCheckService } from './core-health-check.service';
+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';
+import { CoreHealthCheckService } from './core-health-check.service.js';
 
 /**
  * This is a module that imports the TerminusModule and includes a HealthController.
@@ -12,6 +15,17 @@ import { CoreHealthCheckService } from './core-health-check.service';
 @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.resolver.ts

@@ -1,9 +1,9 @@
 import { Query, Resolver } from '@nestjs/graphql';
 
-import { Roles } from '../../common/decorators/roles.decorator';
-import { RoleEnum } from '../../common/enums/role.enum';
-import { CoreHealthCheckResult } from './core-health-check-result.model';
-import { CoreHealthCheckService } from './core-health-check.service';
+import { Roles } from '../../common/decorators/roles.decorator.js';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { CoreHealthCheckResult } from './core-health-check-result.model.js';
+import { CoreHealthCheckService } from './core-health-check.service.js';
 
 /**
  * Resolver to process with user data

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

@@ -1,16 +1,18 @@
-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 type { MongoosePingCheckSettings } from '@nestjs/terminus/dist/health-indicator/database/mongoose.health.js';
-import type { DiskHealthIndicatorOptions } from '@nestjs/terminus/dist/health-indicator/disk/disk-health-options.type.js';
 
-import { getBuildInfo } from '../../common/helpers/meta.helper';
-import { ConfigService } from '../../common/services/config.service';
+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';
 
 /**
  * Core health check service
@@ -20,21 +22,50 @@ import { ConfigService } from '../../common/services/config.service';
 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')) {
-      healthIndicatorFunctions.push(() =>
-        this.db.pingCheck(
+    // 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
+        // configuration keeps working once the option is gone from the indicator.
+        // Same effective timeouts as before: 300 ms without configured options, otherwise the
+        // configured `timeout`, otherwise Terminus' own default (1000 ms).
+        const { timeout, ...options } = this.config.get<MongoosePingCheckSettings>(
+          'healthCheck.configs.database.options',
+        ) ?? { timeout: 300 };
+        const attempt = this.db.pingCheck(
           this.config.get<string>('healthCheck.configs.database.key') ?? 'database',
-          this.config.get<MongoosePingCheckSettings>('healthCheck.configs.database.options') ?? { timeout: 300 },
-        ),
-      );
+          options,
+        );
+        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(() =>