@tahminator/sapling 2.1.0 → 2.1.2

package/README.md

@@ -26,6 +26,10 @@ A lightweight Express.js dependency injection & route abstraction library.
     + [Automatic Spec Generation](#automatic-spec-generation)
     + [Adding Documentation with Decorators](#adding-documentation-with-decorators)
     + [Customizing Paths](#customizing-paths)
+  * [Health Checks](#health-checks)
+    + [Liveness and Readiness Probes](#liveness-and-readiness-probes)
+    + [Registering Custom Readiness Checks](#registering-custom-readiness-checks)
+    + [Customizing Health Paths](#customizing-health-paths)
   * [Custom Serialization](#custom-serialization)
 - [Advanced Setup](#advanced-setup)
   * [Automatically import controllers](#automatically-import-controllers)
@@ -97,9 +101,10 @@ class UserController {
   }
 }
 
-// you still have full access of app to do whatever you want!
-const app = express();
-Sapling.registerApp(app);
+// registerApp returns the app back to you - use the returned app instance
+// so Sapling can inject some post-startup hooks into the app.
+// BUT, you still have full access of app to do whatever you want!
+const app = Sapling.registerApp(express());
 
 // @MiddlewareClass should be registered first before @Controller and should be registered in order
 // @Injectable classes will automatically be formed into singletons by Sapling behind the scenes!
@@ -581,6 +586,57 @@ Sapling.Extras.swaggerAndOpenApi.setOpenApiPath("/api-spec.json");
 Sapling.Extras.swaggerAndOpenApi.setSwaggerPath("/api-docs");
 ```
 
+### Health Checks
+
+#### Liveness and Readiness Probes
+
+Register `DefaultHealthMiddleware` to expose two health endpoints:
+
+- `GET /live` — **liveness probe**: returns `{ up: true }` once the server has started listening. Use this to tell your orchestrator the process is alive.
+- `GET /ready` — **readiness probe**: returns `{ up: true }` once the server is live *and* all registered readiness checks pass. Use this to gate traffic until your app is fully initialized.
+
+```typescript
+import { Sapling, DefaultHealthMiddleware } from "@tahminator/sapling";
+
+const app = Sapling.registerApp(express());
+
+app.use(Sapling.resolve(DefaultHealthMiddleware));
+
+app.listen(3000); // _markLive() is called automatically once the server is listening
+```
+
+> [!IMPORTANT]
+> `Sapling.registerApp` returns `express.App` - please use that as your `app` object inside of your server. There is a small post-startup hook applied via a proxy, in which the liveness probe is enabled from such.
+
+#### Registering Custom Readiness Checks
+
+Inject `HealthRegistrar` into any `@Injectable` or controller to add readiness checks. A check is any function returning `boolean | Promise<boolean>`. If any check returns `false` (or throws), `/ready` reports `{ up: false }`.
+
+```typescript
+import { Injectable, HealthRegistrar } from "@tahminator/sapling";
+
+@Injectable([HealthRegistrar])
+class DatabaseService {
+  constructor(
+    private readonly db: Database,
+    private readonly healthRegistrar: HealthRegistrar,
+  ) {
+    healthRegistrar.add(async () => {
+      return this.db.isConnected();
+    });
+  }
+}
+```
+
+#### Customizing Health Paths
+
+The default paths are `/live` and `/ready`. Override them before registering `DefaultHealthMiddleware`:
+
+```typescript
+Sapling.Extras.health.setLivePath("/healthz/live");
+Sapling.Extras.health.setReadyPath("/healthz/ready");
+```
+
 ### Custom Serialization
 
 By default, Sapling uses `JSON.stringify` and `JSON.parse` for serialization. You can override these with custom serializers like [superjson](https://github.com/flightcontrolhq/superjson#readme) to automatically handle Dates, BigInts, and more:

package/dist/index.cjs

@@ -270,10 +270,181 @@ var ParserError = class ParserError extends ResponseStatusError {
 	}
 };
 //#endregion
+//#region lib/weakmap.ts
+/**
+* WeakMap that is iterable.
+*/
+var IterableWeakMap = class IterableWeakMap {
+	#weakMap = /* @__PURE__ */ new WeakMap();
+	#refSet = /* @__PURE__ */ new Set();
+	#finalizationGroup = new FinalizationRegistry(IterableWeakMap.#cleanup);
+	static #cleanup(heldValue) {
+		heldValue.set.delete(heldValue.ref);
+	}
+	constructor(iterable) {
+		if (iterable) for (const [key, value] of iterable) this.set(key, value);
+	}
+	set(key, value) {
+		const ref = new WeakRef(key);
+		this.#weakMap.set(key, {
+			value,
+			ref
+		});
+		this.#refSet.add(ref);
+		this.#finalizationGroup.register(key, {
+			set: this.#refSet,
+			ref
+		}, ref);
+		return this;
+	}
+	get(key) {
+		return this.#weakMap.get(key)?.value;
+	}
+	delete(key) {
+		const entry = this.#weakMap.get(key);
+		if (!entry) return false;
+		this.#weakMap.delete(key);
+		this.#refSet.delete(entry.ref);
+		this.#finalizationGroup.unregister(entry.ref);
+		return true;
+	}
+	*[Symbol.iterator]() {
+		for (const ref of this.#refSet) {
+			const key = ref.deref();
+			if (!key) continue;
+			const entry = this.#weakMap.get(key);
+			if (entry) yield [key, entry.value];
+		}
+	}
+	entries() {
+		return this[Symbol.iterator]();
+	}
+	*keys() {
+		for (const [key] of this) yield key;
+	}
+	*values() {
+		for (const [, value] of this) yield value;
+	}
+	forEach(callback, thisArg) {
+		for (const [key, value] of this) callback.call(thisArg, value, key, this);
+	}
+};
+//#endregion
+//#region src/annotation/injectable.ts
+const _InjectableRegistry = /* @__PURE__ */ new WeakMap();
+const _InjectableDeps = new IterableWeakMap();
+/**
+* Mark the class as an injectable to be handled by Sapling. The class can now be
+* be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
+*
+* @argument deps - An optional array to define any dependencies that this class may require.
+*/
+function Injectable(deps = []) {
+	return function(target) {
+		_InjectableRegistry.set(target, null);
+		_InjectableDeps.set(target, deps);
+	};
+}
+/**
+* Resolves and instantiates a class along with all of it's transitive dependencies.
+*
+* Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
+* in a correct order.
+*
+* When `resolve` is first called (usually during controller registration),
+* it will compute the dependency graph of all `@Injectable` classes and instantiates
+* them in the correct order.
+*
+* Subsequent calls to dependencies that have already been resolved are cached, so they will
+* re-use the created singletons instead of re-instantiation.
+*/
+function _resolve(ctor) {
+	const inDegree = /* @__PURE__ */ new Map();
+	const graph = /* @__PURE__ */ new Map();
+	_InjectableDeps.forEach((deps, node) => {
+		inDegree.set(node, inDegree.get(node) || 0);
+		deps.forEach((dep) => {
+			if (dep === void 0) throw new Error(`There is an @Injectable (${node.name}) which has a dependency that cannot be found. This is likely caused by a circular dependency.`);
+			inDegree.set(dep, inDegree.get(dep) || 0);
+			inDegree.set(node, inDegree.get(node) + 1);
+			if (!graph.has(dep)) graph.set(dep, []);
+			graph.get(dep).push(node);
+		});
+	});
+	const queue = [];
+	inDegree.forEach((deg, node) => {
+		if (deg === 0) queue.push(node);
+	});
+	while (queue.length) {
+		const current = queue.shift();
+		if (!_InjectableRegistry.get(current)) {
+			const instance = new current(...(_InjectableDeps.get(current) || []).map((dep) => _InjectableRegistry.get(dep)));
+			_InjectableRegistry.set(current, instance);
+		}
+		(graph.get(current) || []).forEach((neighbor) => {
+			inDegree.set(neighbor, (inDegree.get(neighbor) ?? 0) - 1);
+			if (inDegree.get(neighbor) === 0) queue.push(neighbor);
+		});
+	}
+	if (!_InjectableRegistry.get(ctor)) throw new Error("Circular dependency detected or injectable not registered");
+	return _InjectableRegistry.get(ctor);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/middleware/health/registrar.ts
+let HealthRegistrar = class HealthRegistrar {
+	_checks;
+	_live;
+	constructor() {
+		this._checks = [];
+		this._live = false;
+	}
+	/**
+	* Add a health check.
+	*
+	* Health checks will be used to determine whether service can serve traffic or not (a.k.a `readiness`).
+	*/
+	add(healthCheck) {
+		this._checks.push(healthCheck);
+	}
+	/**
+	* @internal used by Sapling library, used to determine once all
+	* checks have been registered and server is, at the very least, alive.
+	*/
+	_markLive() {
+		this._live = true;
+	}
+	/**
+	* @internal
+	*/
+	async _liveness() {
+		return this._live;
+	}
+	/**
+	* @internal
+	*/
+	async _readiness() {
+		if (!this._live) return false;
+		return (await Promise.allSettled(this._checks.map((c) => c()))).every((r) => r.status === "fulfilled" && r.value);
+	}
+};
+HealthRegistrar = __decorate([Injectable()], HealthRegistrar);
+//#endregion
 //#region src/helper/sapling.ts
 const _settings = {
 	serialize: JSON.stringify,
 	deserialize: JSON.parse,
+	health: {
+		ready: { path: "/readyz" },
+		live: { path: "/livez" }
+	},
 	doc: {
 		openApiPath: "/openapi.json",
 		swaggerPath: "/swagger.html",
@@ -341,14 +512,34 @@ var Sapling = class Sapling {
 	* import { Sapling } from "@tahminator/sapling";
 	* import express from "express";
 	*
-	* const app = express();
-	*
-	* app.registerApp(app);
+	* // returns the exact same `express.App` type back to you!
+	* const app = Sapling.registerApp(express());
 	* ```
 	*/
 	static registerApp(app) {
 		app.use(express.default.text({ type: "application/json" }));
 		app.use(Sapling.json());
+		return new Proxy(app, { get(target, prop, receiver) {
+			if (prop === "listen") {
+				const originalListen = target[prop];
+				return function(...args) {
+					const server = originalListen.apply(target, args);
+					server.once("listening", () => {
+						Sapling._onPostStartup();
+						console.log("Sapling successfully initialized post-startup hooks on server start");
+					});
+					return server;
+				};
+			}
+			return Reflect.get(target, prop, receiver);
+		} });
+	}
+	/**
+	* @internal
+	* visible for testing
+	*/
+	static _onPostStartup() {
+		_InjectableRegistry.get(HealthRegistrar)?._markLive();
 	}
 	/**
 	* Serialize a value into a JSON string.
@@ -389,37 +580,59 @@ var Sapling = class Sapling {
 	/**
 	* Modify extra settings
 	*/
-	static Extras = { 
-	/**
-	* Modify default settings applied to OpenAPI & Swagger
-	*/
-swaggerAndOpenApi: {
-		/**
-		* Set base OpenAPI metadata values.
-		*
-		* @default { title: "API", version: "1.0.0" }
-		*/
-		setMetadata(metadata) {
-			_settings.doc.metadata = metadata;
-		},
+	static Extras = {
 		/**
-		* change default endpoint that will serve OpenAPI spec.
-		* Swagger will also load this endpoint on load.
-		*
-		* @default `/openapi.json`
+		* Modify default settings applied to OpenAPI & Swagger
 		*/
-		setOpenApiPath(path) {
-			_settings.doc.openApiPath = path;
+		swaggerAndOpenApi: {
+			/**
+			* Set base OpenAPI metadata values.
+			*
+			* @default { title: "API", version: "1.0.0" }
+			*/
+			setMetadata(metadata) {
+				_settings.doc.metadata = metadata;
+			},
+			/**
+			* change default endpoint that will serve OpenAPI spec.
+			* Swagger will also load this endpoint on load.
+			*
+			* @default `/openapi.json`
+			*/
+			setOpenApiPath(path) {
+				_settings.doc.openApiPath = path;
+			},
+			/**
+			* change Swagger endpoint.
+			*
+			* @default `/swagger.html`
+			*/
+			setSwaggerPath(path) {
+				_settings.doc.swaggerPath = path;
+			}
 		},
 		/**
-		* change Swagger endpoint.
-		*
-		* @default `/swagger.html`
+		* Modify default settings applied to health / readiness / liveness.
 		*/
-		setSwaggerPath(path) {
-			_settings.doc.swaggerPath = path;
+		health: {
+			/**
+			* change default endpoint that ready endpoint will be served on.
+			*
+			* @default `/readyz`
+			*/
+			setReadyPath(path) {
+				_settings.health.ready.path = path;
+			},
+			/**
+			* change default endpoint that live endpoint will be served on.
+			*
+			* @default `/livez`
+			*/
+			setLivePath(path) {
+				_settings.health.live.path = path;
+			}
 		}
-	} };
+	};
 	/**
 	* This method can be used in a `@MiddlewareClass` to register any libraries
 	* that expect you to register multiple registers at once. An example is `swagger-ui-express`
@@ -774,126 +987,6 @@ const methodResolve = {
 	USE: "use"
 };
 //#endregion
-//#region lib/weakmap.ts
-/**
-* WeakMap that is iterable.
-*/
-var IterableWeakMap = class IterableWeakMap {
-	#weakMap = /* @__PURE__ */ new WeakMap();
-	#refSet = /* @__PURE__ */ new Set();
-	#finalizationGroup = new FinalizationRegistry(IterableWeakMap.#cleanup);
-	static #cleanup(heldValue) {
-		heldValue.set.delete(heldValue.ref);
-	}
-	constructor(iterable) {
-		if (iterable) for (const [key, value] of iterable) this.set(key, value);
-	}
-	set(key, value) {
-		const ref = new WeakRef(key);
-		this.#weakMap.set(key, {
-			value,
-			ref
-		});
-		this.#refSet.add(ref);
-		this.#finalizationGroup.register(key, {
-			set: this.#refSet,
-			ref
-		}, ref);
-		return this;
-	}
-	get(key) {
-		return this.#weakMap.get(key)?.value;
-	}
-	delete(key) {
-		const entry = this.#weakMap.get(key);
-		if (!entry) return false;
-		this.#weakMap.delete(key);
-		this.#refSet.delete(entry.ref);
-		this.#finalizationGroup.unregister(entry.ref);
-		return true;
-	}
-	*[Symbol.iterator]() {
-		for (const ref of this.#refSet) {
-			const key = ref.deref();
-			if (!key) continue;
-			const entry = this.#weakMap.get(key);
-			if (entry) yield [key, entry.value];
-		}
-	}
-	entries() {
-		return this[Symbol.iterator]();
-	}
-	*keys() {
-		for (const [key] of this) yield key;
-	}
-	*values() {
-		for (const [, value] of this) yield value;
-	}
-	forEach(callback, thisArg) {
-		for (const [key, value] of this) callback.call(thisArg, value, key, this);
-	}
-};
-//#endregion
-//#region src/annotation/injectable.ts
-const _InjectableRegistry = /* @__PURE__ */ new WeakMap();
-const _InjectableDeps = new IterableWeakMap();
-/**
-* Mark the class as an injectable to be handled by Sapling. The class can now be
-* be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
-*
-* @argument deps - An optional array to define any dependencies that this class may require.
-*/
-function Injectable(deps = []) {
-	return function(target) {
-		_InjectableRegistry.set(target, null);
-		_InjectableDeps.set(target, deps);
-	};
-}
-/**
-* Resolves and instantiates a class along with all of it's transitive dependencies.
-*
-* Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
-* in a correct order.
-*
-* When `resolve` is first called (usually during controller registration),
-* it will compute the dependency graph of all `@Injectable` classes and instantiates
-* them in the correct order.
-*
-* Subsequent calls to dependencies that have already been resolved are cached, so they will
-* re-use the created singletons instead of re-instantiation.
-*/
-function _resolve(ctor) {
-	const inDegree = /* @__PURE__ */ new Map();
-	const graph = /* @__PURE__ */ new Map();
-	_InjectableDeps.forEach((deps, node) => {
-		inDegree.set(node, inDegree.get(node) || 0);
-		deps.forEach((dep) => {
-			if (dep === void 0) throw new Error(`There is an @Injectable (${node.name}) which has a dependency that cannot be found. This is likely caused by a circular dependency.`);
-			inDegree.set(dep, inDegree.get(dep) || 0);
-			inDegree.set(node, inDegree.get(node) + 1);
-			if (!graph.has(dep)) graph.set(dep, []);
-			graph.get(dep).push(node);
-		});
-	});
-	const queue = [];
-	inDegree.forEach((deg, node) => {
-		if (deg === 0) queue.push(node);
-	});
-	while (queue.length) {
-		const current = queue.shift();
-		if (!_InjectableRegistry.get(current)) {
-			const instance = new current(...(_InjectableDeps.get(current) || []).map((dep) => _InjectableRegistry.get(dep)));
-			_InjectableRegistry.set(current, instance);
-		}
-		(graph.get(current) || []).forEach((neighbor) => {
-			inDegree.set(neighbor, (inDegree.get(neighbor) ?? 0) - 1);
-			if (inDegree.get(neighbor) === 0) queue.push(neighbor);
-		});
-	}
-	if (!_InjectableRegistry.get(ctor)) throw new Error("Circular dependency detected or injectable not registered");
-	return _InjectableRegistry.get(ctor);
-}
-//#endregion
 //#region src/annotation/controller.ts
 const _ControllerRegistry = /* @__PURE__ */ new WeakMap();
 /**
@@ -1012,14 +1105,6 @@ function MiddlewareClass(...args) {
 	return Controller(...args);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-//#endregion
 //#region src/middleware/default/error/base.ts
 let DefaultBaseErrorMiddleware = class DefaultBaseErrorMiddleware {
 	handle(err, _request, _response, _next) {
@@ -1135,6 +1220,24 @@ const DefaultSwaggerMiddleware = {
 	Setup
 };
 //#endregion
+//#region src/middleware/default/health/index.ts
+let DefaultHealthMiddleware = class DefaultHealthMiddleware {
+	constructor(healthRegistrar) {
+		this.healthRegistrar = healthRegistrar;
+	}
+	async readiness(_request, _response, _next) {
+		const up = await this.healthRegistrar._readiness();
+		return ResponseEntity.status(up ? 200 : 503).body({ up });
+	}
+	async liveness(_request, _response, _next) {
+		const up = await this.healthRegistrar._liveness();
+		return ResponseEntity.status(up ? 200 : 503).body({ up });
+	}
+};
+__decorate([GET(_settings.health.ready.path)], DefaultHealthMiddleware.prototype, "readiness", null);
+__decorate([GET(_settings.health.live.path)], DefaultHealthMiddleware.prototype, "liveness", null);
+DefaultHealthMiddleware = __decorate([MiddlewareClass({ deps: [HealthRegistrar] })], DefaultHealthMiddleware);
+//#endregion
 exports.Controller = Controller;
 exports.ControllerSchema = ControllerSchema;
 exports.DELETE = DELETE;
@@ -1144,6 +1247,12 @@ Object.defineProperty(exports, "DefaultBaseErrorMiddleware", {
 		return DefaultBaseErrorMiddleware;
 	}
 });
+Object.defineProperty(exports, "DefaultHealthMiddleware", {
+	enumerable: true,
+	get: function() {
+		return DefaultHealthMiddleware;
+	}
+});
 Object.defineProperty(exports, "DefaultOpenApiMiddleware", {
 	enumerable: true,
 	get: function() {
@@ -1165,6 +1274,12 @@ Object.defineProperty(exports, "DefaultResponseStatusErrorMiddleware", {
 exports.DefaultSwaggerMiddleware = DefaultSwaggerMiddleware;
 exports.GET = GET;
 exports.HEAD = HEAD;
+Object.defineProperty(exports, "HealthRegistrar", {
+	enumerable: true,
+	get: function() {
+		return HealthRegistrar;
+	}
+});
 exports.Html404ErrorPage = Html404ErrorPage;
 exports.HttpStatus = HttpStatus;
 exports.Injectable = Injectable;

package/dist/index.d.cts

@@ -794,6 +794,14 @@ declare function _clearOpenApiRegistry(): void;
 type Settings = {
   serialize: (value: any) => string;
   deserialize: (value: string) => any;
+  health: {
+    ready: {
+      path: string;
+    };
+    live: {
+      path: string;
+    };
+  };
   doc: {
     openApiPath: string;
     swaggerPath: string;
@@ -840,12 +848,16 @@ declare class Sapling {
    * import { Sapling } from "@tahminator/sapling";
    * import express from "express";
    *
-   * const app = express();
-   *
-   * app.registerApp(app);
+   * // returns the exact same `express.App` type back to you!
+   * const app = Sapling.registerApp(express());
    * ```
    */
-  static registerApp(app: e.Express): void;
+  static registerApp(app: e.Express): e.Express;
+  /**
+   * @internal
+   * visible for testing
+   */
+  static _onPostStartup(): void;
   /**
    * Serialize a value into a JSON string.
    *
@@ -902,6 +914,23 @@ declare class Sapling {
        */
       setSwaggerPath(this: void, path: string): void;
     };
+    /**
+     * Modify default settings applied to health / readiness / liveness.
+     */
+    health: {
+      /**
+       * change default endpoint that ready endpoint will be served on.
+       *
+       * @default `/readyz`
+       */
+      setReadyPath(this: void, path: string): void;
+      /**
+       * change default endpoint that live endpoint will be served on.
+       *
+       * @default `/livez`
+       */
+      setLivePath(this: void, path: string): void;
+    };
   };
   /**
    * This method can be used in a `@MiddlewareClass` to register any libraries
@@ -1089,4 +1118,48 @@ declare const DefaultSwaggerMiddleware: {
   Setup: typeof Setup;
 };
 //#endregion
-export { Class, Controller, ControllerSchema, ControllerSchemaDefinition, DELETE, DefaultBaseErrorMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, OpenAPIMetadata, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseSchema, ResponseStatusError, RouteDefinition, RouteSchema, RouteSchemaDefinition, Sapling, ValidatorSchema, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };
+//#region src/middleware/health/registrar.d.ts
+type HealthCheck = () => boolean | Promise<boolean>;
+declare class HealthRegistrar {
+  private _checks;
+  private _live;
+  constructor();
+  /**
+   * Add a health check.
+   *
+   * Health checks will be used to determine whether service can serve traffic or not (a.k.a `readiness`).
+   */
+  add(healthCheck: HealthCheck): void;
+  /**
+   * @internal used by Sapling library, used to determine once all
+   * checks have been registered and server is, at the very least, alive.
+   */
+  _markLive(): void;
+  /**
+   * @internal
+   */
+  _liveness(): Promise<boolean>;
+  /**
+   * @internal
+   */
+  _readiness(): Promise<boolean>;
+}
+//#endregion
+//#region src/middleware/default/health/index.d.ts
+/**
+ * Enable the serving of `ready` and `live` endpoints.
+ *
+ * Configure any middleware-specific settings with `Sapling.Extras.health`
+ */
+declare class DefaultHealthMiddleware {
+  private readonly healthRegistrar;
+  constructor(healthRegistrar: HealthRegistrar);
+  readiness(_request: Request, _response: Response$1, _next: NextFunction): Promise<ResponseEntity<{
+    up: boolean;
+  }>>;
+  liveness(_request: Request, _response: Response$1, _next: NextFunction): Promise<ResponseEntity<{
+    up: boolean;
+  }>>;
+}
+//#endregion
+export { Class, Controller, ControllerSchema, ControllerSchemaDefinition, DELETE, DefaultBaseErrorMiddleware, DefaultHealthMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, HealthCheck, HealthRegistrar, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, OpenAPIMetadata, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseSchema, ResponseStatusError, RouteDefinition, RouteSchema, RouteSchemaDefinition, Sapling, ValidatorSchema, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };

package/dist/index.d.mts

@@ -794,6 +794,14 @@ declare function _clearOpenApiRegistry(): void;
 type Settings = {
   serialize: (value: any) => string;
   deserialize: (value: string) => any;
+  health: {
+    ready: {
+      path: string;
+    };
+    live: {
+      path: string;
+    };
+  };
   doc: {
     openApiPath: string;
     swaggerPath: string;
@@ -840,12 +848,16 @@ declare class Sapling {
    * import { Sapling } from "@tahminator/sapling";
    * import express from "express";
    *
-   * const app = express();
-   *
-   * app.registerApp(app);
+   * // returns the exact same `express.App` type back to you!
+   * const app = Sapling.registerApp(express());
    * ```
    */
-  static registerApp(app: e.Express): void;
+  static registerApp(app: e.Express): e.Express;
+  /**
+   * @internal
+   * visible for testing
+   */
+  static _onPostStartup(): void;
   /**
    * Serialize a value into a JSON string.
    *
@@ -902,6 +914,23 @@ declare class Sapling {
        */
       setSwaggerPath(this: void, path: string): void;
     };
+    /**
+     * Modify default settings applied to health / readiness / liveness.
+     */
+    health: {
+      /**
+       * change default endpoint that ready endpoint will be served on.
+       *
+       * @default `/readyz`
+       */
+      setReadyPath(this: void, path: string): void;
+      /**
+       * change default endpoint that live endpoint will be served on.
+       *
+       * @default `/livez`
+       */
+      setLivePath(this: void, path: string): void;
+    };
   };
   /**
    * This method can be used in a `@MiddlewareClass` to register any libraries
@@ -1089,4 +1118,48 @@ declare const DefaultSwaggerMiddleware: {
   Setup: typeof Setup;
 };
 //#endregion
-export { Class, Controller, ControllerSchema, ControllerSchemaDefinition, DELETE, DefaultBaseErrorMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, OpenAPIMetadata, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseSchema, ResponseStatusError, RouteDefinition, RouteSchema, RouteSchemaDefinition, Sapling, ValidatorSchema, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };
+//#region src/middleware/health/registrar.d.ts
+type HealthCheck = () => boolean | Promise<boolean>;
+declare class HealthRegistrar {
+  private _checks;
+  private _live;
+  constructor();
+  /**
+   * Add a health check.
+   *
+   * Health checks will be used to determine whether service can serve traffic or not (a.k.a `readiness`).
+   */
+  add(healthCheck: HealthCheck): void;
+  /**
+   * @internal used by Sapling library, used to determine once all
+   * checks have been registered and server is, at the very least, alive.
+   */
+  _markLive(): void;
+  /**
+   * @internal
+   */
+  _liveness(): Promise<boolean>;
+  /**
+   * @internal
+   */
+  _readiness(): Promise<boolean>;
+}
+//#endregion
+//#region src/middleware/default/health/index.d.ts
+/**
+ * Enable the serving of `ready` and `live` endpoints.
+ *
+ * Configure any middleware-specific settings with `Sapling.Extras.health`
+ */
+declare class DefaultHealthMiddleware {
+  private readonly healthRegistrar;
+  constructor(healthRegistrar: HealthRegistrar);
+  readiness(_request: Request, _response: Response$1, _next: NextFunction): Promise<ResponseEntity<{
+    up: boolean;
+  }>>;
+  liveness(_request: Request, _response: Response$1, _next: NextFunction): Promise<ResponseEntity<{
+    up: boolean;
+  }>>;
+}
+//#endregion
+export { Class, Controller, ControllerSchema, ControllerSchemaDefinition, DELETE, DefaultBaseErrorMiddleware, DefaultHealthMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, HealthCheck, HealthRegistrar, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, OpenAPIMetadata, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseSchema, ResponseStatusError, RouteDefinition, RouteSchema, RouteSchemaDefinition, Sapling, ValidatorSchema, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };

package/dist/index.mjs

@@ -245,10 +245,181 @@ var ParserError = class ParserError extends ResponseStatusError {
 	}
 };
 //#endregion
+//#region lib/weakmap.ts
+/**
+* WeakMap that is iterable.
+*/
+var IterableWeakMap = class IterableWeakMap {
+	#weakMap = /* @__PURE__ */ new WeakMap();
+	#refSet = /* @__PURE__ */ new Set();
+	#finalizationGroup = new FinalizationRegistry(IterableWeakMap.#cleanup);
+	static #cleanup(heldValue) {
+		heldValue.set.delete(heldValue.ref);
+	}
+	constructor(iterable) {
+		if (iterable) for (const [key, value] of iterable) this.set(key, value);
+	}
+	set(key, value) {
+		const ref = new WeakRef(key);
+		this.#weakMap.set(key, {
+			value,
+			ref
+		});
+		this.#refSet.add(ref);
+		this.#finalizationGroup.register(key, {
+			set: this.#refSet,
+			ref
+		}, ref);
+		return this;
+	}
+	get(key) {
+		return this.#weakMap.get(key)?.value;
+	}
+	delete(key) {
+		const entry = this.#weakMap.get(key);
+		if (!entry) return false;
+		this.#weakMap.delete(key);
+		this.#refSet.delete(entry.ref);
+		this.#finalizationGroup.unregister(entry.ref);
+		return true;
+	}
+	*[Symbol.iterator]() {
+		for (const ref of this.#refSet) {
+			const key = ref.deref();
+			if (!key) continue;
+			const entry = this.#weakMap.get(key);
+			if (entry) yield [key, entry.value];
+		}
+	}
+	entries() {
+		return this[Symbol.iterator]();
+	}
+	*keys() {
+		for (const [key] of this) yield key;
+	}
+	*values() {
+		for (const [, value] of this) yield value;
+	}
+	forEach(callback, thisArg) {
+		for (const [key, value] of this) callback.call(thisArg, value, key, this);
+	}
+};
+//#endregion
+//#region src/annotation/injectable.ts
+const _InjectableRegistry = /* @__PURE__ */ new WeakMap();
+const _InjectableDeps = new IterableWeakMap();
+/**
+* Mark the class as an injectable to be handled by Sapling. The class can now be
+* be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
+*
+* @argument deps - An optional array to define any dependencies that this class may require.
+*/
+function Injectable(deps = []) {
+	return function(target) {
+		_InjectableRegistry.set(target, null);
+		_InjectableDeps.set(target, deps);
+	};
+}
+/**
+* Resolves and instantiates a class along with all of it's transitive dependencies.
+*
+* Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
+* in a correct order.
+*
+* When `resolve` is first called (usually during controller registration),
+* it will compute the dependency graph of all `@Injectable` classes and instantiates
+* them in the correct order.
+*
+* Subsequent calls to dependencies that have already been resolved are cached, so they will
+* re-use the created singletons instead of re-instantiation.
+*/
+function _resolve(ctor) {
+	const inDegree = /* @__PURE__ */ new Map();
+	const graph = /* @__PURE__ */ new Map();
+	_InjectableDeps.forEach((deps, node) => {
+		inDegree.set(node, inDegree.get(node) || 0);
+		deps.forEach((dep) => {
+			if (dep === void 0) throw new Error(`There is an @Injectable (${node.name}) which has a dependency that cannot be found. This is likely caused by a circular dependency.`);
+			inDegree.set(dep, inDegree.get(dep) || 0);
+			inDegree.set(node, inDegree.get(node) + 1);
+			if (!graph.has(dep)) graph.set(dep, []);
+			graph.get(dep).push(node);
+		});
+	});
+	const queue = [];
+	inDegree.forEach((deg, node) => {
+		if (deg === 0) queue.push(node);
+	});
+	while (queue.length) {
+		const current = queue.shift();
+		if (!_InjectableRegistry.get(current)) {
+			const instance = new current(...(_InjectableDeps.get(current) || []).map((dep) => _InjectableRegistry.get(dep)));
+			_InjectableRegistry.set(current, instance);
+		}
+		(graph.get(current) || []).forEach((neighbor) => {
+			inDegree.set(neighbor, (inDegree.get(neighbor) ?? 0) - 1);
+			if (inDegree.get(neighbor) === 0) queue.push(neighbor);
+		});
+	}
+	if (!_InjectableRegistry.get(ctor)) throw new Error("Circular dependency detected or injectable not registered");
+	return _InjectableRegistry.get(ctor);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/middleware/health/registrar.ts
+let HealthRegistrar = class HealthRegistrar {
+	_checks;
+	_live;
+	constructor() {
+		this._checks = [];
+		this._live = false;
+	}
+	/**
+	* Add a health check.
+	*
+	* Health checks will be used to determine whether service can serve traffic or not (a.k.a `readiness`).
+	*/
+	add(healthCheck) {
+		this._checks.push(healthCheck);
+	}
+	/**
+	* @internal used by Sapling library, used to determine once all
+	* checks have been registered and server is, at the very least, alive.
+	*/
+	_markLive() {
+		this._live = true;
+	}
+	/**
+	* @internal
+	*/
+	async _liveness() {
+		return this._live;
+	}
+	/**
+	* @internal
+	*/
+	async _readiness() {
+		if (!this._live) return false;
+		return (await Promise.allSettled(this._checks.map((c) => c()))).every((r) => r.status === "fulfilled" && r.value);
+	}
+};
+HealthRegistrar = __decorate([Injectable()], HealthRegistrar);
+//#endregion
 //#region src/helper/sapling.ts
 const _settings = {
 	serialize: JSON.stringify,
 	deserialize: JSON.parse,
+	health: {
+		ready: { path: "/readyz" },
+		live: { path: "/livez" }
+	},
 	doc: {
 		openApiPath: "/openapi.json",
 		swaggerPath: "/swagger.html",
@@ -316,14 +487,34 @@ var Sapling = class Sapling {
 	* import { Sapling } from "@tahminator/sapling";
 	* import express from "express";
 	*
-	* const app = express();
-	*
-	* app.registerApp(app);
+	* // returns the exact same `express.App` type back to you!
+	* const app = Sapling.registerApp(express());
 	* ```
 	*/
 	static registerApp(app) {
 		app.use(e.text({ type: "application/json" }));
 		app.use(Sapling.json());
+		return new Proxy(app, { get(target, prop, receiver) {
+			if (prop === "listen") {
+				const originalListen = target[prop];
+				return function(...args) {
+					const server = originalListen.apply(target, args);
+					server.once("listening", () => {
+						Sapling._onPostStartup();
+						console.log("Sapling successfully initialized post-startup hooks on server start");
+					});
+					return server;
+				};
+			}
+			return Reflect.get(target, prop, receiver);
+		} });
+	}
+	/**
+	* @internal
+	* visible for testing
+	*/
+	static _onPostStartup() {
+		_InjectableRegistry.get(HealthRegistrar)?._markLive();
 	}
 	/**
 	* Serialize a value into a JSON string.
@@ -364,37 +555,59 @@ var Sapling = class Sapling {
 	/**
 	* Modify extra settings
 	*/
-	static Extras = { 
-	/**
-	* Modify default settings applied to OpenAPI & Swagger
-	*/
-swaggerAndOpenApi: {
+	static Extras = {
 		/**
-		* Set base OpenAPI metadata values.
-		*
-		* @default { title: "API", version: "1.0.0" }
+		* Modify default settings applied to OpenAPI & Swagger
 		*/
-		setMetadata(metadata) {
-			_settings.doc.metadata = metadata;
-		},
-		/**
-		* change default endpoint that will serve OpenAPI spec.
-		* Swagger will also load this endpoint on load.
-		*
-		* @default `/openapi.json`
-		*/
-		setOpenApiPath(path) {
-			_settings.doc.openApiPath = path;
+		swaggerAndOpenApi: {
+			/**
+			* Set base OpenAPI metadata values.
+			*
+			* @default { title: "API", version: "1.0.0" }
+			*/
+			setMetadata(metadata) {
+				_settings.doc.metadata = metadata;
+			},
+			/**
+			* change default endpoint that will serve OpenAPI spec.
+			* Swagger will also load this endpoint on load.
+			*
+			* @default `/openapi.json`
+			*/
+			setOpenApiPath(path) {
+				_settings.doc.openApiPath = path;
+			},
+			/**
+			* change Swagger endpoint.
+			*
+			* @default `/swagger.html`
+			*/
+			setSwaggerPath(path) {
+				_settings.doc.swaggerPath = path;
+			}
 		},
 		/**
-		* change Swagger endpoint.
-		*
-		* @default `/swagger.html`
+		* Modify default settings applied to health / readiness / liveness.
 		*/
-		setSwaggerPath(path) {
-			_settings.doc.swaggerPath = path;
+		health: {
+			/**
+			* change default endpoint that ready endpoint will be served on.
+			*
+			* @default `/readyz`
+			*/
+			setReadyPath(path) {
+				_settings.health.ready.path = path;
+			},
+			/**
+			* change default endpoint that live endpoint will be served on.
+			*
+			* @default `/livez`
+			*/
+			setLivePath(path) {
+				_settings.health.live.path = path;
+			}
 		}
-	} };
+	};
 	/**
 	* This method can be used in a `@MiddlewareClass` to register any libraries
 	* that expect you to register multiple registers at once. An example is `swagger-ui-express`
@@ -749,126 +962,6 @@ const methodResolve = {
 	USE: "use"
 };
 //#endregion
-//#region lib/weakmap.ts
-/**
-* WeakMap that is iterable.
-*/
-var IterableWeakMap = class IterableWeakMap {
-	#weakMap = /* @__PURE__ */ new WeakMap();
-	#refSet = /* @__PURE__ */ new Set();
-	#finalizationGroup = new FinalizationRegistry(IterableWeakMap.#cleanup);
-	static #cleanup(heldValue) {
-		heldValue.set.delete(heldValue.ref);
-	}
-	constructor(iterable) {
-		if (iterable) for (const [key, value] of iterable) this.set(key, value);
-	}
-	set(key, value) {
-		const ref = new WeakRef(key);
-		this.#weakMap.set(key, {
-			value,
-			ref
-		});
-		this.#refSet.add(ref);
-		this.#finalizationGroup.register(key, {
-			set: this.#refSet,
-			ref
-		}, ref);
-		return this;
-	}
-	get(key) {
-		return this.#weakMap.get(key)?.value;
-	}
-	delete(key) {
-		const entry = this.#weakMap.get(key);
-		if (!entry) return false;
-		this.#weakMap.delete(key);
-		this.#refSet.delete(entry.ref);
-		this.#finalizationGroup.unregister(entry.ref);
-		return true;
-	}
-	*[Symbol.iterator]() {
-		for (const ref of this.#refSet) {
-			const key = ref.deref();
-			if (!key) continue;
-			const entry = this.#weakMap.get(key);
-			if (entry) yield [key, entry.value];
-		}
-	}
-	entries() {
-		return this[Symbol.iterator]();
-	}
-	*keys() {
-		for (const [key] of this) yield key;
-	}
-	*values() {
-		for (const [, value] of this) yield value;
-	}
-	forEach(callback, thisArg) {
-		for (const [key, value] of this) callback.call(thisArg, value, key, this);
-	}
-};
-//#endregion
-//#region src/annotation/injectable.ts
-const _InjectableRegistry = /* @__PURE__ */ new WeakMap();
-const _InjectableDeps = new IterableWeakMap();
-/**
-* Mark the class as an injectable to be handled by Sapling. The class can now be
-* be injected into other classes, as well as allow the class to inject other `@Injectable` classes.
-*
-* @argument deps - An optional array to define any dependencies that this class may require.
-*/
-function Injectable(deps = []) {
-	return function(target) {
-		_InjectableRegistry.set(target, null);
-		_InjectableDeps.set(target, deps);
-	};
-}
-/**
-* Resolves and instantiates a class along with all of it's transitive dependencies.
-*
-* Uses topological sort (Kahn's algorithm) to ensure that the dependency graph is created
-* in a correct order.
-*
-* When `resolve` is first called (usually during controller registration),
-* it will compute the dependency graph of all `@Injectable` classes and instantiates
-* them in the correct order.
-*
-* Subsequent calls to dependencies that have already been resolved are cached, so they will
-* re-use the created singletons instead of re-instantiation.
-*/
-function _resolve(ctor) {
-	const inDegree = /* @__PURE__ */ new Map();
-	const graph = /* @__PURE__ */ new Map();
-	_InjectableDeps.forEach((deps, node) => {
-		inDegree.set(node, inDegree.get(node) || 0);
-		deps.forEach((dep) => {
-			if (dep === void 0) throw new Error(`There is an @Injectable (${node.name}) which has a dependency that cannot be found. This is likely caused by a circular dependency.`);
-			inDegree.set(dep, inDegree.get(dep) || 0);
-			inDegree.set(node, inDegree.get(node) + 1);
-			if (!graph.has(dep)) graph.set(dep, []);
-			graph.get(dep).push(node);
-		});
-	});
-	const queue = [];
-	inDegree.forEach((deg, node) => {
-		if (deg === 0) queue.push(node);
-	});
-	while (queue.length) {
-		const current = queue.shift();
-		if (!_InjectableRegistry.get(current)) {
-			const instance = new current(...(_InjectableDeps.get(current) || []).map((dep) => _InjectableRegistry.get(dep)));
-			_InjectableRegistry.set(current, instance);
-		}
-		(graph.get(current) || []).forEach((neighbor) => {
-			inDegree.set(neighbor, (inDegree.get(neighbor) ?? 0) - 1);
-			if (inDegree.get(neighbor) === 0) queue.push(neighbor);
-		});
-	}
-	if (!_InjectableRegistry.get(ctor)) throw new Error("Circular dependency detected or injectable not registered");
-	return _InjectableRegistry.get(ctor);
-}
-//#endregion
 //#region src/annotation/controller.ts
 const _ControllerRegistry = /* @__PURE__ */ new WeakMap();
 /**
@@ -987,14 +1080,6 @@ function MiddlewareClass(...args) {
 	return Controller(...args);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-//#endregion
 //#region src/middleware/default/error/base.ts
 let DefaultBaseErrorMiddleware = class DefaultBaseErrorMiddleware {
 	handle(err, _request, _response, _next) {
@@ -1110,4 +1195,22 @@ const DefaultSwaggerMiddleware = {
 	Setup
 };
 //#endregion
-export { Controller, ControllerSchema, DELETE, DefaultBaseErrorMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, GET, HEAD, Html404ErrorPage, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, PATCH, POST, PUT, ParserError, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseStatusError, RouteSchema, Sapling, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };
+//#region src/middleware/default/health/index.ts
+let DefaultHealthMiddleware = class DefaultHealthMiddleware {
+	constructor(healthRegistrar) {
+		this.healthRegistrar = healthRegistrar;
+	}
+	async readiness(_request, _response, _next) {
+		const up = await this.healthRegistrar._readiness();
+		return ResponseEntity.status(up ? 200 : 503).body({ up });
+	}
+	async liveness(_request, _response, _next) {
+		const up = await this.healthRegistrar._liveness();
+		return ResponseEntity.status(up ? 200 : 503).body({ up });
+	}
+};
+__decorate([GET(_settings.health.ready.path)], DefaultHealthMiddleware.prototype, "readiness", null);
+__decorate([GET(_settings.health.live.path)], DefaultHealthMiddleware.prototype, "liveness", null);
+DefaultHealthMiddleware = __decorate([MiddlewareClass({ deps: [HealthRegistrar] })], DefaultHealthMiddleware);
+//#endregion
+export { Controller, ControllerSchema, DELETE, DefaultBaseErrorMiddleware, DefaultHealthMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, GET, HEAD, HealthRegistrar, Html404ErrorPage, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, PATCH, POST, PUT, ParserError, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseStatusError, RouteSchema, Sapling, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tahminator/sapling",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "author": "Tahmid Ahmed",
   "description": "A library to help you write cleaner Express.js code",
   "repository": {