@db3.ai/app 0.1.0-beta.1 → 0.1.0

package/src/db/examples/FieldNote.ts

@@ -1,13 +1,13 @@
-import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db';
+import { ActiveRecord } from '@db3.ai/app/db';
 import { NoteCodeField } from './NoteCodeField';
 
 /** A disposable guide model demonstrating reusable and JSON-backed field values. */
-export class FieldNote extends ActiveRecord {
-	static override table = 'field_notes';
-	static override requestFillable = ['code', 'tags', 'metadata'];
+export class FieldNote extends ActiveRecord.define({
+	table: 'field_notes',
+	requestFillable: ['code', 'tags', 'metadata'],
 
 	/** Declares one place for input, validation, storage and public-output policy. */
-	static override fields(field: FieldBuilder) {
+	fields(field) {
 		return {
 			id: field.ulid(),
 			owner: field.string({ column: 'owner_id', required: true, index: true }),
@@ -16,12 +16,6 @@ export class FieldNote extends ActiveRecord {
 			metadata: field.json<{ client: { name: string }; draft: boolean }>(),
 			integration: field.encryptedJson<{ token: string }>({ column: 'integration_secret', selectedByDefault: false }),
 		};
-	}
-
-	declare id: string | null;
-	declare owner: string | null;
-	declare code: string | null;
-	declare tags: string[];
-	declare metadata: { client: { name: string }; draft: boolean } | null;
-	declare integration: { token: string } | null;
+	},
+}) {
 }

package/src/db/examples/KnowledgeNote.ts

@@ -1,9 +1,9 @@
-import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db';
+import { ActiveRecord } from '@db3.ai/app/db';
 
 /** A workspace-owned note used by the ActiveRecord guide and executable recipe. */
-export class KnowledgeNote extends ActiveRecord {
-	static override table = 'knowledge_notes';
-	static override requestFillable = ['title', 'body'];
+export class KnowledgeNote extends ActiveRecord.define({
+	table: 'knowledge_notes',
+	requestFillable: ['title', 'body'],
 
 	/**
 	 * Defines storage, validation and transport behaviour for each logical field.
@@ -11,7 +11,7 @@ export class KnowledgeNote extends ActiveRecord {
 	 * @param field - Framework field factory.
 	 * @returns The note's schema; workspace ownership is assigned by trusted code.
 	 */
-	static override fields(field: FieldBuilder) {
+	fields(field) {
 		return {
 			id: field.ulid(),
 			workspace: field.string({ column: 'workspace_id', required: true, maxLength: 26, index: true }),
@@ -19,11 +19,5 @@ export class KnowledgeNote extends ActiveRecord {
 			body: field.text(),
 			createdAt: field.timestamp({ column: 'created_at', auto: 'create' }),
 		};
-	}
-
-	declare id: string | null;
-	declare workspace: string | null;
-	declare title: string | null;
-	declare body: string | null;
-	declare createdAt: Date | null;
-}
+	},
+}) {}

package/src/db/examples/runNoteMigrations.ts

@@ -2,27 +2,27 @@ import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { ActiveRecord, DatabaseMigrationManager, mariaDbDialect, type FieldBuilder } from '@db3.ai/app/db';
+import { ActiveRecord, DatabaseMigrationManager, mariaDbDialect } from '@db3.ai/app/db';
 import { createGeneratedTestDatabase } from '@db3.ai/app/db/test/db';
 
 /** Initial version of a disposable note table, before a schema change. */
-class InitialNote extends ActiveRecord {
-	static override table = 'migration_guide_notes';
+class InitialNote extends ActiveRecord.define({
+	table: 'migration_guide_notes',
 	/** Defines the initial committed schema. */
-	static override fields(field: FieldBuilder) { return { id: field.ulid(), title: field.string({ required: true }) }; }
-}
+	fields(field) { return { id: field.ulid(), title: field.string({ required: true }) }; },
+}) {}
 
 /** Unsafe proposal: existing rows have no value for this required column. */
-class RequiredCategoryNote extends InitialNote {
+class RequiredCategoryNote extends InitialNote.define({
 	/** Adds a required field without pretending existing data has a value. */
-	static override fields(field: FieldBuilder) { return { ...super.fields(field), category: field.string({ required: true }) }; }
-}
+	fields(field) { return { category: field.string({ required: true }) }; },
+}) {}
 
 /** Repaired additive change that can be deployed before backfilling existing rows. */
-class OptionalCategoryNote extends InitialNote {
+class OptionalCategoryNote extends InitialNote.define({
 	/** Adds a nullable field safe for the existing note. */
-	static override fields(field: FieldBuilder) { return { ...super.fields(field), category: field.string() }; }
-}
+	fields(field) { return { category: field.string() }; },
+}) {}
 
 /**
  * Generates, applies and checks migrations against an owned disposable database.

package/src/db/fields/TimestampField.ts

@@ -1,3 +1,4 @@
+import { utcDate } from '@db3.ai/pure/dates';
 import {
 	BasicFieldState,
 	DbSchemaPart,
@@ -46,21 +47,7 @@ export class TimestampField extends FieldType<
 	 * Parses app input into a Date object.
 	 */
 	protected override parse(input: unknown): Date | null {
-		if (input === null || input === undefined || input === '') {
-			return null;
-		}
-
-		if (input instanceof Date) {
-			return input;
-		}
-
-		const date = new Date(String(input));
-
-		if (Number.isNaN(date.getTime())) {
-			return null;
-		}
-
-		return date;
+		return input instanceof Date || typeof input === 'string' ? utcDate(input) : null;
 	}
 
 	/**
@@ -73,12 +60,16 @@ export class TimestampField extends FieldType<
 	/**
 	 * Converts app-memory Date to database value.
 	 */
-	protected override toDbValue(input: Date | null): Date | null {
+	protected override toDbValue(input: Date | null): Date | string | null {
 		if (input === null || input === undefined) {
 			return null;
 		}
 
-		return input;
+		// PostgreSQL timestamp-without-timezone ignores offsets on Date parameters.
+		// Send UTC calendar components explicitly rather than the driver's local rendering.
+		return this.schemaDialect().name === 'postgres'
+			? input.toISOString().replace('T', ' ').replace('Z', '')
+			: input;
 	}
 
 	protected override defaultFormComponent(): string {

package/src/db/migrations/DatabaseMigrationManager.ts

@@ -26,6 +26,7 @@ import type {
 	MakeMigrationResult,
 	MigrateOptions,
 	MigrateResult,
+	RollbackResult,
 	SchemaMigrationPlan,
 	SchemaSnapshot,
 } from './contracts';
@@ -35,7 +36,7 @@ import {
 	DatabaseMigrationLockError,
 	DatabaseMigrationSourceGenerationError,
 } from './errors';
-import { renderKnexMigration } from './KnexMigrationRenderer';
+import { renderKnexMigration } from './renderKnexMigration';
 import { collectModelSchema } from './ModelSchemaCollector';
 import { diffSchemaSnapshots } from './SchemaDiffer';
 import { promoteDestructiveSchemaChanges } from './promoteDestructiveSchemaChanges';
@@ -57,7 +58,7 @@ const DEFAULT_LOAD_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs'] as const;
 export class DatabaseMigrationManager {
 	readonly #options: Required<Pick<
 		DatabaseMigrationManagerOptions,
-		'migrationTableName' | 'loadExtensions' | 'environment' | 'generationLockFile' | 'now'
+		'migrationTableName' | 'loadExtensions' | 'migrationExtension' | 'environment' | 'generationLockFile' | 'now'
 	>> & DatabaseMigrationManagerOptions;
 
 	/**
@@ -82,6 +83,7 @@ export class DatabaseMigrationManager {
 			...options,
 			models: [...options.models],
 			migrationTableName: options.migrationTableName ?? DEFAULT_MIGRATION_TABLE,
+			migrationExtension: options.migrationExtension ?? '.ts',
 			loadExtensions: options.loadExtensions ?? DEFAULT_LOAD_EXTENSIONS,
 			environment: options.environment ?? process.env.NODE_ENV ?? 'development',
 			generationLockFile,
@@ -200,6 +202,12 @@ export class DatabaseMigrationManager {
 		};
 	}
 
+	/** Runs the latest committed migration's own down function. The caller must quiesce consumers first. */
+	async rollback(): Promise<RollbackResult> {
+		const [batch, names] = await this.#options.db.migrate.down(this.#knexConfig());
+		return { reverted: names.map(String), batch: typeof batch === 'number' ? batch : null };
+	}
+
 	/**
 	 * Runs the development convenience flow under one generation lock.
 	 *
@@ -272,9 +280,9 @@ export class DatabaseMigrationManager {
 		const name = migrationName(options.name, plan);
 		const file = join(
 			this.#options.migrationsDirectory,
-			`${formatMigrationTimestamp(this.#options.now())}_${name}.ts`,
+			`${formatMigrationTimestamp(this.#options.now())}_${name}${this.#options.migrationExtension}`,
 		);
-		const source = renderKnexMigration(plan);
+		const source = renderKnexMigration(plan, this.#options.migrationExtension === '.mjs' ? 'javascript' : 'typescript');
 
 		await writeMigrationAndSnapshotAtomically(
 			file,

package/src/db/migrations/contracts/DatabaseMigration.ts

@@ -31,6 +31,9 @@ export interface DatabaseMigrationManagerOptions {
 	/** Migration file extensions Knex may load. */
 	loadExtensions?: readonly string[];
 
+	/** Generated migration format. Use .mjs for assets shared unchanged with npm packages. */
+	migrationExtension?: '.ts' | '.mjs';
+
 	/** Current application environment. Source generation is refused in production. */
 	environment?: string;
 
@@ -141,3 +144,9 @@ export interface DatabaseSyncResult {
 	migrate: MigrateResult | null;
 	check: DatabaseCheckResult | null;
 }
+
+/** Result of executing the latest migration's app-authored down function. */
+export interface RollbackResult {
+	reverted: string[];
+	batch: number | null;
+}

package/src/db/migrations/index.ts

@@ -2,7 +2,7 @@ export * from './contracts';
 export * from './DatabaseMigrationManager';
 export * from './DatabaseSchemaInspector';
 export * from './errors';
-export * from './KnexMigrationRenderer';
+export * from './renderKnexMigration';
 export * from './ModelSchemaCollector';
 export * from './promoteDestructiveSchemaChanges';
 export * from './SchemaDiffer';

package/src/db/migrations/{KnexMigrationRenderer.ts → renderKnexMigration.ts}

@@ -1,22 +1,16 @@
-import type {
-	SafeSchemaChange,
-	SchemaColumn,
-	SchemaForeignKey,
-	SchemaIndex,
-	SchemaMigrationPlan,
-	SchemaTable,
-} from './contracts';
+import type { SafeSchemaChange, SchemaColumn, SchemaForeignKey, SchemaIndex, SchemaMigrationPlan, SchemaTable } from './contracts';
 
 /**
- * Renders a frozen TypeScript Knex migration from a safe schema plan.
+ * Renders a frozen TypeScript or JavaScript Knex migration from a safe schema plan.
  *
  * Generated source contains literal table, column, index, and foreign-key
  * operations. It never imports current models or field implementations.
  *
  * @param plan - Pure schema plan with no blocked changes.
- * @returns Deterministic TypeScript migration source.
+ * @param language - JavaScript keeps migration bytes identical in local and packaged apps.
+ * @returns Deterministic migration source.
  */
-export function renderKnexMigration(plan: SchemaMigrationPlan): string {
+export function renderKnexMigration(plan: SchemaMigrationPlan, language: 'typescript' | 'javascript' = 'typescript'): string {
 	if (plan.blockedChanges.length > 0) {
 		throw new Error('Cannot render a migration plan containing blocked changes.');
 	}
@@ -26,7 +20,7 @@ export function renderKnexMigration(plan: SchemaMigrationPlan): string {
 	}
 
 	const lines = [
-		"import type { Knex } from 'knex';",
+		...(language === 'typescript' ? ["import type { Knex } from 'knex';"] : []),
 		'',
 		'/** Knex migration settings for MariaDB non-transactional DDL. */',
 		'export const config = { transaction: false };',
@@ -43,7 +37,7 @@ export function renderKnexMigration(plan: SchemaMigrationPlan): string {
 		' * @param knex - Knex connection managed by the application migration runner.',
 		' * @returns Promise that resolves after every schema operation completes.',
 		' */',
-		'export async function up(knex: Knex): Promise<void> {',
+		language === 'typescript' ? 'export async function up(knex: Knex): Promise<void> {' : 'export async function up(knex) {',
 	];
 
 	const body = renderMigrationBody(plan.safeChanges);
@@ -58,7 +52,7 @@ export function renderKnexMigration(plan: SchemaMigrationPlan): string {
 		' * @param _knex - Unused Knex connection supplied by the migration runner.',
 		' * @returns Promise that always rejects before performing database DDL.',
 		' */',
-		'export async function down(_knex: Knex): Promise<void> {',
+		language === 'typescript' ? 'export async function down(_knex: Knex): Promise<void> {' : 'export async function down(_knex) {',
 		"\tthrow new Error('Generated database migrations are forward-only.');",
 		'}',
 		'',

package/src/flows/FlowCompiler.ts

@@ -4,7 +4,7 @@ import { FLOW_INPUT_BLOCK_TYPE, FLOW_OUTPUT_BLOCK_TYPE } from './blocks';
 import type { CompiledFlowBlock, CompiledFlowDefinition, FlowBlockDefinition, FlowBlockInstance, FlowConnection, FlowDefinition, FlowExecutionDefinition, FlowValueDefinition, FlowValueDefinitions } from './contracts';
 import { FlowBlockRegistry } from './FlowBlockRegistry';
 import { FlowDefinitionError, type FlowDefinitionIssue } from './FlowDefinitionError';
-import { matchesDefinition, validateFlowValues } from './FlowValueValidator';
+import { matchesDefinition, validateFlowValues } from './flowValueValidator';
 
 const FLOW_VALUE_TYPES = new Set([
 	'string',

package/src/flows/Flows.ts

@@ -8,7 +8,7 @@ import { FlowCompiler } from './FlowCompiler';
 import { FlowDefinitionError } from './FlowDefinitionError';
 import { flowErrorSnapshot } from './errors';
 import { FlowStepJob } from './FlowStepJob';
-import { validateFlowValues } from './FlowValueValidator';
+import { validateFlowValues } from './flowValueValidator';
 import { FlowRun, FlowRunEvent, FlowStepRun } from './models';
 
 const DEFAULT_MAX_PAYLOAD_BYTES = 1024 * 1024;

package/src/flows/index.ts

@@ -9,5 +9,5 @@ export * from './FlowCompiler';
 export * from './FlowDefinitionError';
 export * from './Flows';
 export * from './FlowStepJob';
-export * from './FlowValueValidator';
+export * from './flowValueValidator';
 export * from './models';

package/src/health/Health.ts

@@ -0,0 +1,163 @@
+import type * as health from './contracts';
+
+const STATUS_PRIORITY: Record<health.HealthStatus, number> = {
+	ok: 0,
+	degraded: 1,
+	unhealthy: 2,
+};
+
+/** Aggregates framework and application component checks into one safe report. */
+export class Health {
+	readonly #service: string;
+	readonly #timeoutMs: number;
+	readonly #checks = new Map<string, health.HealthCheck>();
+
+	/**
+	 * Creates an application health registry with the framework runtime check.
+	 *
+	 * @param options - Service identity and initial application checks.
+	 */
+	constructor(options: health.HealthOptions = {}) {
+		this.#service = options.service?.trim() || 'application';
+		this.#timeoutMs = positiveTimeout(options.timeoutMs);
+		this.register('application', () => ({ status: 'ok' }));
+
+		for (const [name, check] of Object.entries(options.checks ?? {})) {
+			this.register(name, check);
+		}
+	}
+
+	/**
+	 * Registers or replaces one named component check.
+	 *
+	 * Stable names let applications override a framework default without
+	 * producing duplicate output.
+	 *
+	 * @param name - Public component name used as the report key.
+	 * @param check - Bounded check that returns only public-safe details.
+	 * @returns This health service for fluent registration.
+	 */
+	register(name: string, check: health.HealthCheck): this {
+		const normalized = normalizeCheckName(name);
+
+		if (typeof check !== 'function') throw new TypeError(`Health check "${normalized}" must be a function.`);
+		this.#checks.set(normalized, check);
+		return this;
+	}
+
+	/**
+	 * Removes one optional component check.
+	 *
+	 * The framework-owned application check cannot be removed because it makes
+	 * the default endpoint useful without any application configuration.
+	 *
+	 * @param name - Registered component name.
+	 * @returns Whether an application-owned check was removed.
+	 */
+	remove(name: string): boolean {
+		const normalized = normalizeCheckName(name);
+		if (normalized === 'application') return false;
+		return this.#checks.delete(normalized);
+	}
+
+	/**
+	 * Executes all checks concurrently and returns a public-safe aggregate.
+	 *
+	 * Thrown values are contained and converted to a generic unhealthy result;
+	 * applications must log diagnostic details inside their check when needed.
+	 *
+	 * @returns Current aggregate and per-component health state.
+	 */
+	async report(): Promise<health.HealthReport> {
+		const entries = await Promise.all(
+			[...this.#checks.entries()].map(async ([name, check]) => {
+				const startedAt = performance.now();
+				let result: health.HealthCheckResult;
+
+				try {
+					result = normalizeCheckResult(await withTimeout(check(), this.#timeoutMs));
+				} catch {
+					result = { status: 'unhealthy', message: 'Health check failed.' };
+				}
+
+				return [name, {
+					...result,
+					durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+				}] as const;
+			}),
+		);
+		const checks = Object.fromEntries(entries);
+		const status = entries.reduce<health.HealthStatus>((current, [, result]) => {
+			return STATUS_PRIORITY[result.status] > STATUS_PRIORITY[current] ? result.status : current;
+		}, 'ok');
+
+		return {
+			status,
+			service: this.#service,
+			timestamp: new Date().toISOString(),
+			checks,
+		};
+	}
+}
+
+/**
+ * Normalizes and validates a public component name.
+ *
+ * @param name - Caller-supplied check name.
+ * @returns Trimmed stable report key.
+ */
+function normalizeCheckName(name: string): string {
+	const normalized = name.trim();
+	if (!normalized) throw new TypeError('Health check names cannot be empty.');
+	return normalized;
+}
+
+/**
+ * Applies the healthy default and validates a component result.
+ *
+ * @param result - Value returned by a registered health check.
+ * @returns Validated public-safe component result.
+ */
+function normalizeCheckResult(result: health.HealthCheckResult | void): health.HealthCheckResult {
+	if (result === undefined) return { status: 'ok' };
+	if (!Object.hasOwn(STATUS_PRIORITY, result.status)) throw new TypeError(`Unsupported health status "${String(result.status)}".`);
+
+	return result.message
+		? { status: result.status, message: result.message }
+		: { status: result.status };
+}
+
+/**
+ * Resolves the bounded per-check timeout.
+ *
+ * @param timeoutMs - Optional application override.
+ * @returns Positive timeout in milliseconds.
+ */
+function positiveTimeout(timeoutMs: number | undefined): number {
+	if (timeoutMs === undefined) return 3000;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new TypeError('Health timeoutMs must be a positive number.');
+	return timeoutMs;
+}
+
+/**
+ * Prevents a stuck dependency from hanging the aggregate health endpoint.
+ *
+ * @param result - Check result or promise returned by the application.
+ * @param timeoutMs - Maximum time allowed for the check.
+ * @returns Check result before the timeout expires.
+ */
+async function withTimeout(result: ReturnType<health.HealthCheck>, timeoutMs: number): Promise<health.HealthCheckResult | void> {
+	let timer: NodeJS.Timeout | undefined;
+
+	try {
+		return await Promise.race([
+			Promise.resolve(result),
+			new Promise<never>((_resolve, reject) => {
+				timer = setTimeout(() => reject(new Error('Health check timed out.')), timeoutMs);
+				timer.unref();
+			}),
+		]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}

package/src/health/README.md

@@ -0,0 +1,46 @@
+# Health
+
+`@db3.ai/app/health` provides a small application health registry. It owns the
+safe aggregate result while concrete HTTP adapters expose it to load balancers,
+deployment gates and uptime monitors.
+
+Every `App` has an `app().health` service with an `application` check, so a new
+application can expose `/health` without defining custom checks. Applications
+extend the report with stable names:
+
+```ts
+import { databaseHealthCheck } from '@db3.ai/app/health';
+
+application.health
+	.register('database', databaseHealthCheck(application.db))
+	.register('search-provider', async () => ({
+		status: providerConfigured ? 'ok' : 'degraded',
+		message: providerConfigured ? undefined : 'Optional search features are unavailable.',
+	}));
+```
+
+Checks run concurrently with a three-second per-check timeout by default. A thrown value becomes a generic unhealthy result and
+does not leak its error message through the public endpoint. Log private details
+inside the application check when an operator needs them.
+
+## Fastify
+
+Register the canonical endpoint from `@db3.ai/app/health/fastify`:
+
+```ts
+import { registerHealthRoute } from '@db3.ai/app/health/fastify';
+
+registerHealthRoute(server, {
+	app: application,
+	path: '/health',
+	aliases: ['/healthz'],
+});
+```
+
+The endpoint returns `200` for `ok` and `degraded`, `503` for `unhealthy`, and
+always sends `Cache-Control: no-store`. `/health` is the recommended public path;
+aliases exist only for compatibility with existing infrastructure.
+
+Health is deliberately narrower than telemetry. It answers whether this process
+should receive traffic now. Metrics, traces and logs explain performance and
+incidents over time.

package/src/health/contracts/Health.ts

@@ -0,0 +1,47 @@
+/** Health states shared by aggregate reports and individual component checks. */
+export type HealthStatus = 'ok' | 'degraded' | 'unhealthy';
+
+/** Public-safe result returned by one named health check. */
+export interface HealthCheckResult {
+	/** Current component state. Unhealthy checks make the aggregate endpoint unavailable. */
+	status: HealthStatus;
+
+	/** Optional public-safe explanation suitable for an operator or external monitor. */
+	message?: string;
+}
+
+/** Recorded result for one component in an aggregate health report. */
+export interface HealthCheckReport extends HealthCheckResult {
+	/** Time spent executing this check, rounded to milliseconds. */
+	durationMs: number;
+}
+
+/** Complete application health report returned by the HTTP adapter. */
+export interface HealthReport {
+	/** Aggregate state derived from every registered component check. */
+	status: HealthStatus;
+
+	/** Stable service name configured by the application. */
+	service: string;
+
+	/** ISO timestamp recorded after all component checks complete. */
+	timestamp: string;
+
+	/** Results keyed by the stable names used when checks were registered. */
+	checks: Record<string, HealthCheckReport>;
+}
+
+/** Function used to inspect one framework or application component. */
+export type HealthCheck = () => HealthCheckResult | void | Promise<HealthCheckResult | void>;
+
+/** Configuration accepted when the application health service is created. */
+export interface HealthOptions {
+	/** Stable service name included in every report. */
+	service?: string;
+
+	/** Maximum time allowed for each check, defaulting to 3,000 milliseconds. */
+	timeoutMs?: number;
+
+	/** Initial framework or application checks keyed by stable component name. */
+	checks?: Record<string, HealthCheck>;
+}

package/src/health/contracts/HealthHttp.ts

@@ -0,0 +1,19 @@
+import type { Health } from '../Health';
+
+/** Minimal application shape required by the health HTTP adapter. */
+export interface HealthApplication {
+	/** Health service whose aggregate report is exposed over HTTP. */
+	health: Health;
+}
+
+/** HTTP route configuration shared by supported server adapters. */
+export interface HealthRouteOptions {
+	/** Application that owns the health checks. */
+	app: HealthApplication;
+
+	/** Canonical endpoint path, defaulting to `/health`. */
+	path?: string;
+
+	/** Compatibility paths that return the same report. */
+	aliases?: string[];
+}

package/src/health/contracts/index.ts

@@ -0,0 +1,2 @@
+export type * from './Health';
+export type * from './HealthHttp';

package/src/health/databaseHealthCheck.ts

@@ -0,0 +1,21 @@
+import type { Database } from '../db';
+import type { HealthCheck } from './contracts';
+
+/**
+ * Creates the standard database dependency check used by HTTP applications.
+ *
+ * The query proves the active connection can accept work without inspecting
+ * application tables or mutating customer data.
+ *
+ * @param database - Framework database service to query.
+ * @returns Health check suitable for `app().health.register()`.
+ *
+ * @example
+ * app().health.register('database', databaseHealthCheck(app().db));
+ */
+export function databaseHealthCheck(database: Database): HealthCheck {
+	return async () => {
+		await database.knex.raw('SELECT 1');
+		return { status: 'ok' };
+	};
+}