@tahminator/sapling 2.0.4 → 2.0.5-beta.2f539758

package/dist/index.mjs

@@ -240,7 +240,8 @@ var ParserError = class ParserError extends ResponseStatusError {
 //#region src/helper/sapling.ts
 const settings = {
 	serialize: JSON.stringify,
-	deserialize: JSON.parse
+	deserialize: JSON.parse,
+	openapi: { path: "/openapi.json" }
 };
 /**
 * Collection of utility functions which are essential for Sapling to function.
@@ -345,140 +346,11 @@ var Sapling = class Sapling {
 	static setDeserializeFn(fn) {
 		settings.deserialize = fn;
 	}
-};
-//#endregion
-//#region src/types.ts
-const methodResolve = {
-	GET: "get",
-	PUT: "put",
-	POST: "post",
-	DELETE: "delete",
-	OPTIONS: "options",
-	PATCH: "patch",
-	HEAD: "head",
-	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);
+	static setOpenApiPath(path) {
+		settings.openapi.path = path;
 	}
 };
 //#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/request.ts
 const _requestSchemaStore = /* @__PURE__ */ new WeakMap();
 /**
@@ -687,6 +559,224 @@ function _getRoutes(ctor) {
 	return _routeStore.get(ctor) ?? [];
 }
 //#endregion
+//#region src/helper/openapi.ts
+var OpenAPIGenerator = class {
+	constructor() {
+		this.controllers = /* @__PURE__ */ new Set();
+		this.config = {
+			title: "API",
+			version: "1.0.0"
+		};
+	}
+	setConfig(config) {
+		this.config = config;
+	}
+	registerController(controllerClass, prefix) {
+		this.controllers.add({
+			class: controllerClass,
+			prefix
+		});
+	}
+	generateSpec() {
+		const config = this.config;
+		const paths = {};
+		for (const { class: controllerClass, prefix } of this.controllers) {
+			const routes = _getRoutes(controllerClass);
+			for (const route of routes) {
+				if (route.method === "USE") continue;
+				const schemas = _getRequestSchemas(controllerClass, route.fnName);
+				const fullPath = route.path instanceof RegExp ? route.path.source : prefix + route.path;
+				const openApiPath = typeof fullPath === "string" ? fullPath.replace(/:(\w+)/g, "{$1}") : fullPath;
+				if (!paths[openApiPath]) paths[openApiPath] = {};
+				const operation = { responses: { "200": { description: "Successful response" } } };
+				const parameters = [];
+				if (schemas?.param) {
+					const paramSchema = this.toJsonSchema(schemas.param);
+					if (paramSchema.type === "object" && paramSchema.properties) for (const [name, schema] of Object.entries(paramSchema.properties)) parameters.push({
+						name,
+						in: "path",
+						required: true,
+						schema
+					});
+				}
+				if (schemas?.query) {
+					const querySchema = this.toJsonSchema(schemas.query);
+					if (querySchema.type === "object" && querySchema.properties) for (const [name, schema] of Object.entries(querySchema.properties)) {
+						const isRequired = Array.isArray(querySchema.required) && querySchema.required.includes(name);
+						parameters.push({
+							name,
+							in: "query",
+							required: isRequired,
+							schema
+						});
+					}
+				}
+				if (parameters.length > 0) operation.parameters = parameters;
+				if (schemas?.body) operation.requestBody = {
+					required: true,
+					content: { "application/json": { schema: this.toJsonSchema(schemas.body) } }
+				};
+				const method = route.method.toLowerCase();
+				paths[openApiPath][method] = operation;
+			}
+		}
+		return {
+			openapi: "3.0.0",
+			info: {
+				title: config.title,
+				version: config.version,
+				description: config.description
+			},
+			paths
+		};
+	}
+	toJsonSchema(schema) {
+		return schema["~standard"].jsonSchema.output({ target: "openapi-3.0" });
+	}
+};
+const openApiGenerator = new OpenAPIGenerator();
+function _registerControllerClass(controllerClass, prefix) {
+	openApiGenerator.registerController(controllerClass, prefix);
+}
+function setOpenApiConfig(config) {
+	openApiGenerator.setConfig(config);
+}
+function generateOpenApiSpec() {
+	return openApiGenerator.generateSpec();
+}
+//#endregion
+//#region src/types.ts
+const methodResolve = {
+	GET: "get",
+	PUT: "put",
+	POST: "post",
+	DELETE: "delete",
+	OPTIONS: "options",
+	PATCH: "patch",
+	HEAD: "head",
+	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();
 /**
@@ -698,6 +788,7 @@ const _ControllerRegistry = /* @__PURE__ */ new WeakMap();
 function Controller({ prefix = "", deps = [] } = {}) {
 	return (target) => {
 		const targetClass = target;
+		_registerControllerClass(target, prefix);
 		const router = Router();
 		const routes = _getRoutes(target);
 		const usedRoutes = /* @__PURE__ */ new Set();
@@ -789,7 +880,7 @@ function __decorate(decorators, target, key, desc) {
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 //#endregion
-//#region src/middleware/default/base.ts
+//#region src/middleware/default/error/base.ts
 let DefaultBaseErrorMiddleware = class DefaultBaseErrorMiddleware {
 	handle(err, _request, _response, _next) {
 		console.error("[Error]", err);
@@ -799,7 +890,17 @@ let DefaultBaseErrorMiddleware = class DefaultBaseErrorMiddleware {
 __decorate([Middleware()], DefaultBaseErrorMiddleware.prototype, "handle", null);
 DefaultBaseErrorMiddleware = __decorate([MiddlewareClass()], DefaultBaseErrorMiddleware);
 //#endregion
-//#region src/middleware/default/responsestatus.ts
+//#region src/middleware/default/error/parse.ts
+let DefaultParserErrorMiddleware = class DefaultParserErrorMiddleware {
+	handle(err, _request, _response, next) {
+		if (err instanceof ParserError) return ResponseEntity.status(err.status).body({ message: err.message });
+		next(err);
+	}
+};
+__decorate([Middleware()], DefaultParserErrorMiddleware.prototype, "handle", null);
+DefaultParserErrorMiddleware = __decorate([MiddlewareClass()], DefaultParserErrorMiddleware);
+//#endregion
+//#region src/middleware/default/error/responsestatus.ts
 let DefaultResponseStatusErrorMiddleware = class DefaultResponseStatusErrorMiddleware {
 	handle(err, _request, _response, next) {
 		if (err instanceof ResponseStatusError) return ResponseEntity.status(err.status).body({ message: err.message });
@@ -809,4 +910,13 @@ let DefaultResponseStatusErrorMiddleware = class DefaultResponseStatusErrorMiddl
 __decorate([Middleware()], DefaultResponseStatusErrorMiddleware.prototype, "handle", null);
 DefaultResponseStatusErrorMiddleware = __decorate([MiddlewareClass()], DefaultResponseStatusErrorMiddleware);
 //#endregion
-export { Controller, DELETE, DefaultBaseErrorMiddleware, DefaultResponseStatusErrorMiddleware, GET, HEAD, Html404ErrorPage, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, PATCH, POST, PUT, ParserError, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseEntity, ResponseEntityBuilder, ResponseStatusError, Sapling, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _getRequestSchemas, _getRoutes, _parseOrThrow, _resolve, methodResolve };
+//#region src/middleware/default/openapi/index.ts
+let DefaultOpenApiMiddleware = class DefaultOpenApiMiddleware {
+	handle(_request, _response, _next) {
+		return ResponseEntity.ok().body(generateOpenApiSpec());
+	}
+};
+__decorate([GET("/openapi.json")], DefaultOpenApiMiddleware.prototype, "handle", null);
+DefaultOpenApiMiddleware = __decorate([MiddlewareClass()], DefaultOpenApiMiddleware);
+//#endregion
+export { Controller, DELETE, DefaultBaseErrorMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, GET, HEAD, Html404ErrorPage, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, PATCH, POST, PUT, ParserError, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseEntity, ResponseEntityBuilder, ResponseStatusError, Sapling, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _getRequestSchemas, _getRoutes, _parseOrThrow, _registerControllerClass, _resolve, generateOpenApiSpec, methodResolve, openApiGenerator, setOpenApiConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tahminator/sapling",
-  "version": "2.0.4",
+  "version": "2.0.5-beta.2f539758",
   "author": "Tahmid Ahmed",
   "description": "A library to help you write cleaner Express.js code",
   "repository": {
@@ -45,6 +45,7 @@
     "@types/express": "^5",
     "@types/supertest": "^7.2.0",
     "@vitest/coverage-istanbul": "^4.1.2",
+    "openapi-types": "12.1.3",
     "eslint": "^10.1.0",
     "eslint-plugin-perfectionist": "^5.7.0",
     "globals": "^17.4.0",
@@ -60,6 +61,7 @@
     "zod": "^4.4.3"
   },
   "inlinedDependencies": {
-    "@standard-schema/spec": "1.1.0"
+    "@standard-schema/spec": "1.1.0",
+    "openapi-types": "12.1.3"
   }
 }