I health indicator interface and built in indicators

[saadmoumou]

Summary

• What does this PR change?

Why

• Why is this change needed?

Checklist

• Added/updated tests (if behavior changed)
• npm run lint passes
• npm run typecheck passes
• npm test passes
• npm run build passes
• Added a changeset (npx changeset) if this affects consumers

Notes

• Anything reviewers should pay attention to?

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[Copilot]

Pull request overview

This PR introduces a health indicator contract (IHealthIndicator) plus three built-in indicators (HTTP, Redis, Postgres) with Jest coverage, and updates project tooling/config (TypeScript path aliases, Jest moduleNameMapper, ESLint flat config, lint-staged, Husky hook) to support the new structure.

Changes:

• Added IHealthIndicator + result/status types under src/interfaces/.
• Added built-in health indicators for Redis, Postgres, and HTTP under src/indicators/ with corresponding unit tests.
• Updated TS/Jest path aliasing and refreshed linting + pre-commit automation (ESLint config, lint-staged, Husky).

Reviewed changes

Copilot reviewed 11 out of 14 changed files in this pull request and generated 13 comments.

Show a summary per file

File	Description
tsconfig.json	Adds path aliases for @interfaces/* and @indicators/*.
src/interfaces/health-indicator.interface.ts	Introduces shared health indicator contract and result types.
src/indicators/redis.indicator.ts	Adds Redis health indicator implementation.
src/indicators/redis.indicator.spec.ts	Adds unit tests for Redis indicator.
src/indicators/postgres.indicator.ts	Adds Postgres health indicator implementation.
src/indicators/postgres.indicator.spec.ts	Adds unit tests for Postgres indicator.
src/indicators/http.indicator.ts	Adds HTTP health indicator implementation using fetch + timeout.
src/indicators/http.indicator.spec.ts	Adds unit tests for HTTP indicator.
jest.config.ts	Adds moduleNameMapper entries for new path aliases.
eslint.config.mjs	Updates ESLint flat config (rules, ignores, import ordering, TS setup).
eslint.config.js	Removes redundant/old ESLint config file.
lint-staged.config.mjs	Adds lint-staged configuration for Prettier + ESLint.
.husky/pre-commit	Changes pre-commit hook to run lint-staged.
package-lock.json	Locks updated dev dependency set (includes @eslint/js).

[Copilot]

This Husky hook is missing the shebang and the husky.sh bootstrap line. Without those, Git may fail to execute the hook (e.g., “Exec format error”) and Husky won’t set up the environment consistently. Restore the standard Husky header (as in .husky/pre-push) before running npx lint-staged.

[Copilot]

The docs say message is “required when status is "down"”, but the type makes it optional in all cases. Consider using a discriminated union so message is required for { status: 'down' } and optional/absent for { status: 'up' } to keep the contract enforceable at compile time.

Suggested change

	*/
	export interface HealthIndicatorResult {
	/** Unique name identifying this indicator (e.g. "postgres", "redis"). */
	name: string;
	/** Whether the dependency is healthy. */
	status: HealthStatus;
	/** Optional human-readable message (required when status is "down"). */
	message?: string;
	}
	*
	* When `status` is `"down"`, `message` is required.
	*/
	export type HealthIndicatorResult =
	| {
	/** Unique name identifying this indicator (e.g. "postgres", "redis"). */
	name: string;
	/** Whether the dependency is healthy. */
	status: "up";
	/** Optional human-readable message. */
	message?: string;
	}
	| {
	/** Unique name identifying this indicator (e.g. "postgres", "redis"). */
	name: string;
	/** Whether the dependency is healthy. */
	status: "down";
	/** Human-readable message describing why the dependency is unhealthy. */
	message: string;
	};

[Copilot]

These indicators are marked @Injectable(), but their constructor dependencies are an interface type (RedisClient), which Nest cannot resolve via DI without an explicit injection token / factory provider. Either remove @Injectable() (if consumers should new these) or introduce exported injection tokens (e.g., @Inject(REDIS_CLIENT)) / provider factories so they can be registered as providers safely.

[Copilot]

The indicator description says it “expects a "PONG" response”, but the implementation doesn’t validate the ping() result. As written, any resolved value (even unexpected) reports status: 'up'. Capture the return value and treat non-PONG responses as down (with an explanatory message).

Suggested change

	await Promise.race([this.client.ping(), this._timeout()]);
	const pingResult = await Promise.race([
	this.client.ping(),
	this._timeout(),
	]);
	if (pingResult !== "PONG") {
	return {
	name: "redis",
	status: "down",
	message: `Unexpected PING response: ${String(pingResult)}`,
	};
	}

[Copilot]

_timeout() schedules a setTimeout that is never cleared when ping() wins the race, leaving unnecessary timers running and adding avoidable event-loop work. Consider implementing the timeout with a timer that is cleared in a finally (or a small helper) so successful checks don’t leave pending timeouts behind.

[Copilot]

The JSDoc examples reference HealthModule.register(...), but there is no HealthModule in this package (and it isn’t imported in the example). This makes the example misleading for consumers. Either add the referenced module/API in this PR or update the example to demonstrate the intended integration point that actually exists in the codebase.

Suggested change

	* HealthModule.register({
	* path: 'health',
	* liveness: [],
	* readiness: [
	* new HttpHealthIndicator('https://api.example.com/health'),
	* ],
	* });
	* ```
	*/
	@Injectable()
	export class HttpHealthIndicator implements IHealthIndicator {
	* const indicator = new HttpHealthIndicator('https://api.example.com/health');
	* const result = await indicator.check();
	*
	* console.log(result.status); // "up" | "down"
	* ```
	*/
	@Injectable()
	export class HttpHealthIndicator implements IHealthIndicator {
	*/
	@Injectable()
	export class HttpHealthIndicator implements IHealthIndicator {

[Copilot]

The JSDoc example references HealthModule.register(...), but this package doesn’t currently define/export a HealthModule. Either add the referenced module/API in this PR or update the example to show how consumers should actually wire this indicator into their app.

Suggested change

	*
	* const redis = new Redis({ host: 'localhost', port: 6379 });
	*
	* HealthModule.register({
	* path: 'health',
	* liveness: [],
	* readiness: [new RedisHealthIndicator(redis)],
	* });
	* import { RedisHealthIndicator } from '@ciscode/health-kit';
	*
	* const redis = new Redis({ host: 'localhost', port: 6379 });
	*
	* // Register the indicator in your own health check setup:
	* const redisHealthIndicator = new RedisHealthIndicator(redis);
	*
	* const result = await redisHealthIndicator.check();
	* console.log(result); // { name: 'redis', status: 'up' } on success

[Copilot]

The JSDoc example references HealthModule.register(...), but this package doesn’t currently define/export a HealthModule. Either add the referenced module/API in this PR or update the example to show how consumers should actually wire this indicator into their app.

Suggested change

	* HealthModule.register({
	* path: 'health',
	* liveness: [],
	* readiness: [new PostgresHealthIndicator(pool)],
	* });
	* @Module({
	* providers: [
	* {
	* provide: PostgresHealthIndicator,
	* useFactory: () => new PostgresHealthIndicator(pool),
	* },
	* ],
	* exports: [PostgresHealthIndicator],
	* })
	* export class AppModule {}

[Copilot]

name is hard-coded to "http" in the result. If consumers need to check multiple HTTP endpoints, results will collide and won’t be uniquely identifiable. Consider allowing a configurable name (defaulting to "http") or deriving it from the URL.

[Copilot]

These new health indicator types/classes are not exported from the package’s public entrypoint (src/index.ts), so consumers can’t import them from the module root. If they’re intended for external use, add explicit exports for the interface and built-in indicators.