@navios/core 0.5.1 → 0.7.0

package/lib/use-guards.decorator-DdvUhB03.cjs

@@ -0,0 +1,622 @@
+const require_src = require('./src-Cb1aTjl0.cjs');
+let __navios_di = require("@navios/di");
+
+//#region src/metadata/handler.metadata.mts
+const EndpointMetadataKey = Symbol("EndpointMetadataKey");
+function getAllEndpointMetadata(context) {
+	if (context.metadata) {
+		const metadata = context.metadata[EndpointMetadataKey];
+		if (metadata) return metadata;
+		else {
+			context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
+			return context.metadata[EndpointMetadataKey];
+		}
+	}
+	throw new Error("[Navios] Wrong environment.");
+}
+function getEndpointMetadata(target, context) {
+	if (context.metadata) {
+		const metadata = getAllEndpointMetadata(context);
+		if (metadata) {
+			const endpointMetadata = Array.from(metadata).find((item) => item.classMethod === target.name);
+			if (endpointMetadata) return endpointMetadata;
+			else {
+				const newMetadata = {
+					classMethod: target.name,
+					url: "",
+					successStatusCode: 200,
+					adapterToken: null,
+					headers: {},
+					httpMethod: "GET",
+					config: null,
+					guards: /* @__PURE__ */ new Set(),
+					customAttributes: /* @__PURE__ */ new Map()
+				};
+				metadata.add(newMetadata);
+				return newMetadata;
+			}
+		}
+	}
+	throw new Error("[Navios] Wrong environment.");
+}
+
+//#endregion
+//#region src/metadata/controller.metadata.mts
+const ControllerMetadataKey = Symbol("ControllerMetadataKey");
+function getControllerMetadata(target, context) {
+	if (context.metadata) {
+		const metadata = context.metadata[ControllerMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const newMetadata = {
+				endpoints: getAllEndpointMetadata(context),
+				guards: /* @__PURE__ */ new Set(),
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			context.metadata[ControllerMetadataKey] = newMetadata;
+			target[ControllerMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios] Wrong environment.");
+}
+function extractControllerMetadata(target) {
+	const metadata = target[ControllerMetadataKey];
+	if (!metadata) throw new Error("[Navios] Controller metadata not found. Make sure to use @Controller decorator.");
+	return metadata;
+}
+function hasControllerMetadata(target) {
+	return !!target[ControllerMetadataKey];
+}
+
+//#endregion
+//#region src/metadata/module.metadata.mts
+const ModuleMetadataKey = Symbol("ControllerMetadataKey");
+function getModuleMetadata(target, context) {
+	if (context.metadata) {
+		const metadata = context.metadata[ModuleMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const newMetadata = {
+				controllers: /* @__PURE__ */ new Set(),
+				imports: /* @__PURE__ */ new Set(),
+				guards: /* @__PURE__ */ new Set(),
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			context.metadata[ModuleMetadataKey] = newMetadata;
+			target[ModuleMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios] Wrong environment.");
+}
+function extractModuleMetadata(target) {
+	const metadata = target[ModuleMetadataKey];
+	if (!metadata) throw new Error(`[Navios] Module metadata not found for ${target.name}. Make sure to use @Module decorator.`);
+	return metadata;
+}
+function hasModuleMetadata(target) {
+	return !!target[ModuleMetadataKey];
+}
+
+//#endregion
+//#region src/decorators/controller.decorator.mts
+/**
+* Decorator that marks a class as a Navios controller.
+* 
+* Controllers handle HTTP requests and define endpoints.
+* They are request-scoped by default, meaning a new instance is created for each request.
+* 
+* @param options - Controller configuration options
+* @returns A class decorator
+* 
+* @example
+* ```typescript
+* @Controller({ guards: [AuthGuard] })
+* export class UserController {
+*   @Endpoint(getUserEndpoint)
+*   async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+*     // Handle request
+*   }
+* }
+* ```
+*/ function Controller({ guards } = {}) {
+	return function(target, context) {
+		if (context.kind !== "class") throw new Error("[Navios] @Controller decorator can only be used on classes.");
+		const token = __navios_di.InjectionToken.create(target);
+		if (context.metadata) {
+			const controllerMetadata = getControllerMetadata(target, context);
+			if (guards) for (const guard of Array.from(guards).reverse()) controllerMetadata.guards.add(guard);
+		}
+		return (0, __navios_di.Injectable)({
+			token,
+			scope: __navios_di.InjectableScope.Request
+		})(target, context);
+	};
+}
+
+//#endregion
+//#region src/tokens/endpoint-adapter.token.mts
+const EndpointAdapterToken = __navios_di.InjectionToken.create("EndpointAdapterToken");
+
+//#endregion
+//#region src/tokens/execution-context.token.mts
+const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+const ExecutionContext = __navios_di.InjectionToken.create(ExecutionContextInjectionToken);
+
+//#endregion
+//#region src/tokens/http-adapter.token.mts
+const HttpAdapterToken = __navios_di.InjectionToken.create("HttpAdapterToken");
+
+//#endregion
+//#region src/tokens/multipart-adapter.token.mts
+const MultipartAdapterToken = __navios_di.InjectionToken.create("MultipartAdapterToken");
+
+//#endregion
+//#region src/tokens/reply.token.mts
+const Reply = __navios_di.InjectionToken.create("ReplyToken");
+
+//#endregion
+//#region src/tokens/request.token.mts
+const Request = __navios_di.InjectionToken.create("RequestToken");
+
+//#endregion
+//#region src/tokens/stream-adapter.token.mts
+const StreamAdapterToken = __navios_di.InjectionToken.create("StreamAdapterToken");
+
+//#endregion
+//#region src/tokens/xml-stream-adapter.token.mts
+const XmlStreamAdapterToken = __navios_di.InjectionToken.create("XmlStreamAdapterToken");
+
+//#endregion
+//#region src/decorators/endpoint.decorator.mts
+/**
+* Decorator that marks a method as an HTTP endpoint.
+*
+* The endpoint must be defined using @navios/builder's `declareEndpoint` method.
+* This ensures type safety and consistency between client and server.
+*
+* @param endpoint - The endpoint declaration from @navios/builder
+* @returns A method decorator
+*
+* @example
+* ```typescript
+* import { builder } from '@navios/builder'
+*
+* const api = builder()
+* const getUserEndpoint = api.declareEndpoint({
+*   method: 'get',
+*   url: '/users/$userId',
+*   responseSchema: z.object({ id: z.string(), name: z.string() }),
+* })
+*
+* @Controller()
+* export class UserController {
+*   @Endpoint(getUserEndpoint)
+*   async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+*     const { userId } = request.urlParams
+*     return { id: userId, name: 'John' }
+*   }
+* }
+* ```
+*/ function Endpoint(endpoint) {
+	return (target, context) => {
+		if (context.kind !== "method") throw new Error("[Navios] Endpoint decorator can only be used on methods.");
+		const config = endpoint.config;
+		if (context.metadata) {
+			let endpointMetadata = getEndpointMetadata(target, context);
+			if (endpointMetadata.config && endpointMetadata.config.url) throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`);
+			endpointMetadata.config = config;
+			endpointMetadata.adapterToken = EndpointAdapterToken;
+			endpointMetadata.classMethod = target.name;
+			endpointMetadata.httpMethod = config.method;
+			endpointMetadata.url = config.url;
+		}
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/header.decorator.mts
+/**
+* Decorator that sets a custom HTTP response header for an endpoint.
+* 
+* @param name - The header name (e.g., 'Content-Type', 'Cache-Control')
+* @param value - The header value (string, number, or array of strings)
+* @returns A method decorator
+* 
+* @example
+* ```typescript
+* @Controller()
+* export class UserController {
+*   @Endpoint(getUserEndpoint)
+*   @Header('Cache-Control', 'max-age=3600')
+*   async getUser() {
+*     return { id: '1', name: 'John' }
+*   }
+* }
+* ```
+*/ function Header(name, value) {
+	return (target, context) => {
+		if (context.kind !== "method") throw new Error("[Navios] Header decorator can only be used on methods.");
+		const metadata = getEndpointMetadata(target, context);
+		metadata.headers[name] = value;
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/http-code.decorator.mts
+/**
+* Decorator that sets a custom HTTP status code for successful responses.
+* 
+* By default, endpoints return 200 OK. Use this decorator to return a different status code.
+* 
+* @param code - The HTTP status code to return (e.g., 201, 204, 202)
+* @returns A method decorator
+* 
+* @example
+* ```typescript
+* @Controller()
+* export class UserController {
+*   @Endpoint(createUserEndpoint)
+*   @HttpCode(201)
+*   async createUser() {
+*     return { id: '1', name: 'John' }
+*   }
+* }
+* ```
+*/ function HttpCode(code) {
+	return (target, context) => {
+		if (context.kind !== "method") throw new Error("[Navios] HttpCode decorator can only be used on methods.");
+		const metadata = getEndpointMetadata(target, context);
+		metadata.successStatusCode = code;
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/module.decorator.mts
+/**
+* Decorator that marks a class as a Navios module.
+* 
+* Modules are the basic building blocks of a Navios application.
+* They organize controllers, services, and other modules into logical units.
+* 
+* @param options - Module configuration options
+* @returns A class decorator
+* 
+* @example
+* ```typescript
+* @Module({
+*   controllers: [UserController, AuthController],
+*   imports: [DatabaseModule],
+*   guards: [AuthGuard],
+* })
+* export class AppModule {}
+* ```
+*/ function Module({ controllers = [], imports = [], guards = [] } = {
+	controllers: [],
+	imports: [],
+	guards: []
+}) {
+	return (target, context) => {
+		if (context.kind !== "class") throw new Error("[Navios] @Module decorator can only be used on classes.");
+		const token = __navios_di.InjectionToken.create(target);
+		const moduleMetadata = getModuleMetadata(target, context);
+		for (const controller of controllers) moduleMetadata.controllers.add(controller);
+		for (const importedModule of imports) moduleMetadata.imports.add(importedModule);
+		for (const guard of Array.from(guards).reverse()) moduleMetadata.guards.add(guard);
+		return (0, __navios_di.Injectable)({
+			token,
+			scope: __navios_di.InjectableScope.Singleton
+		})(target, context);
+	};
+}
+
+//#endregion
+//#region src/decorators/multipart.decorator.mts
+/**
+* Decorator that marks a method as a multipart/form-data endpoint.
+* 
+* Use this decorator for endpoints that handle file uploads or form data.
+* The endpoint must be defined using @navios/builder's `declareMultipart` method.
+* 
+* @param endpoint - The multipart endpoint declaration from @navios/builder
+* @returns A method decorator
+* 
+* @example
+* ```typescript
+* const uploadFileEndpoint = api.declareMultipart({
+*   method: 'post',
+*   url: '/upload',
+*   requestSchema: z.object({ file: z.instanceof(File) }),
+*   responseSchema: z.object({ url: z.string() }),
+* })
+* 
+* @Controller()
+* export class FileController {
+*   @Multipart(uploadFileEndpoint)
+*   async uploadFile(request: MultipartParams<typeof uploadFileEndpoint>) {
+*     const { file } = request.data
+*     // Handle file upload
+*     return { url: 'https://example.com/file.jpg' }
+*   }
+* }
+* ```
+*/ function Multipart(endpoint) {
+	return (target, context) => {
+		if (typeof target !== "function") throw new Error("[Navios] Endpoint decorator can only be used on functions.");
+		if (context.kind !== "method") throw new Error("[Navios] Endpoint decorator can only be used on methods.");
+		const config = endpoint.config;
+		if (context.metadata) {
+			let endpointMetadata = getEndpointMetadata(target, context);
+			if (endpointMetadata.config && endpointMetadata.config.url) throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`);
+			endpointMetadata.config = config;
+			endpointMetadata.adapterToken = MultipartAdapterToken;
+			endpointMetadata.classMethod = target.name;
+			endpointMetadata.httpMethod = config.method;
+			endpointMetadata.url = config.url;
+		}
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/stream.decorator.mts
+/**
+* Decorator that marks a method as a streaming endpoint.
+* 
+* Use this decorator for endpoints that stream data (e.g., file downloads, SSE).
+* The endpoint must be defined using @navios/builder's `declareStream` method.
+* 
+* @param endpoint - The stream endpoint declaration from @navios/builder
+* @returns A method decorator
+* 
+* @example
+* ```typescript
+* const downloadFileEndpoint = api.declareStream({
+*   method: 'get',
+*   url: '/files/$fileId',
+* })
+* 
+* @Controller()
+* export class FileController {
+*   @Stream(downloadFileEndpoint)
+*   async downloadFile(request: StreamParams<typeof downloadFileEndpoint>, reply: any) {
+*     const { fileId } = request.urlParams
+*     // Stream file data to reply
+*   }
+* }
+* ```
+*/ function Stream(endpoint) {
+	return (target, context) => {
+		if (typeof target !== "function") throw new Error("[Navios] Endpoint decorator can only be used on functions.");
+		if (context.kind !== "method") throw new Error("[Navios] Endpoint decorator can only be used on methods.");
+		const config = endpoint.config;
+		if (context.metadata) {
+			let endpointMetadata = getEndpointMetadata(target, context);
+			if (endpointMetadata.config && endpointMetadata.config.url) throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`);
+			endpointMetadata.config = config;
+			endpointMetadata.adapterToken = StreamAdapterToken;
+			endpointMetadata.classMethod = target.name;
+			endpointMetadata.httpMethod = config.method;
+			endpointMetadata.url = config.url;
+		}
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/use-guards.decorator.mts
+/**
+* Decorator that applies guards to a controller or endpoint.
+* 
+* Guards are used for authentication, authorization, and request validation.
+* They implement the `CanActivate` interface and are executed before the endpoint handler.
+* Guards can be applied at the module, controller, or endpoint level.
+* 
+* @param guards - Guard classes or injection tokens to apply
+* @returns A class or method decorator
+* 
+* @example
+* ```typescript
+* // Apply to a controller
+* @Controller()
+* @UseGuards(AuthGuard, RoleGuard)
+* export class UserController {
+*   @Endpoint(getUserEndpoint)
+*   async getUser() { }
+* }
+* 
+* // Apply to a specific endpoint
+* @Controller()
+* export class UserController {
+*   @Endpoint(getUserEndpoint)
+*   @UseGuards(AuthGuard)
+*   async getUser() { }
+* }
+* ```
+*/ function UseGuards(...guards) {
+	return function(target, context) {
+		if (context.kind === "class") {
+			const controllerMetadata = getControllerMetadata(target, context);
+			for (const guard of guards.reverse()) controllerMetadata.guards.add(guard);
+		} else if (context.kind === "method") {
+			const endpointMetadata = getEndpointMetadata(target, context);
+			for (const guard of guards.reverse()) endpointMetadata.guards.add(guard);
+		} else throw new Error("[Navios] @UseGuards decorator can only be used on classes or methods.");
+		return target;
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'Controller', {
+  enumerable: true,
+  get: function () {
+    return Controller;
+  }
+});
+Object.defineProperty(exports, 'ControllerMetadataKey', {
+  enumerable: true,
+  get: function () {
+    return ControllerMetadataKey;
+  }
+});
+Object.defineProperty(exports, 'Endpoint', {
+  enumerable: true,
+  get: function () {
+    return Endpoint;
+  }
+});
+Object.defineProperty(exports, 'EndpointAdapterToken', {
+  enumerable: true,
+  get: function () {
+    return EndpointAdapterToken;
+  }
+});
+Object.defineProperty(exports, 'EndpointMetadataKey', {
+  enumerable: true,
+  get: function () {
+    return EndpointMetadataKey;
+  }
+});
+Object.defineProperty(exports, 'ExecutionContext', {
+  enumerable: true,
+  get: function () {
+    return ExecutionContext;
+  }
+});
+Object.defineProperty(exports, 'ExecutionContextInjectionToken', {
+  enumerable: true,
+  get: function () {
+    return ExecutionContextInjectionToken;
+  }
+});
+Object.defineProperty(exports, 'Header', {
+  enumerable: true,
+  get: function () {
+    return Header;
+  }
+});
+Object.defineProperty(exports, 'HttpAdapterToken', {
+  enumerable: true,
+  get: function () {
+    return HttpAdapterToken;
+  }
+});
+Object.defineProperty(exports, 'HttpCode', {
+  enumerable: true,
+  get: function () {
+    return HttpCode;
+  }
+});
+Object.defineProperty(exports, 'Module', {
+  enumerable: true,
+  get: function () {
+    return Module;
+  }
+});
+Object.defineProperty(exports, 'ModuleMetadataKey', {
+  enumerable: true,
+  get: function () {
+    return ModuleMetadataKey;
+  }
+});
+Object.defineProperty(exports, 'Multipart', {
+  enumerable: true,
+  get: function () {
+    return Multipart;
+  }
+});
+Object.defineProperty(exports, 'MultipartAdapterToken', {
+  enumerable: true,
+  get: function () {
+    return MultipartAdapterToken;
+  }
+});
+Object.defineProperty(exports, 'Reply', {
+  enumerable: true,
+  get: function () {
+    return Reply;
+  }
+});
+Object.defineProperty(exports, 'Request', {
+  enumerable: true,
+  get: function () {
+    return Request;
+  }
+});
+Object.defineProperty(exports, 'Stream', {
+  enumerable: true,
+  get: function () {
+    return Stream;
+  }
+});
+Object.defineProperty(exports, 'StreamAdapterToken', {
+  enumerable: true,
+  get: function () {
+    return StreamAdapterToken;
+  }
+});
+Object.defineProperty(exports, 'UseGuards', {
+  enumerable: true,
+  get: function () {
+    return UseGuards;
+  }
+});
+Object.defineProperty(exports, 'XmlStreamAdapterToken', {
+  enumerable: true,
+  get: function () {
+    return XmlStreamAdapterToken;
+  }
+});
+Object.defineProperty(exports, 'extractControllerMetadata', {
+  enumerable: true,
+  get: function () {
+    return extractControllerMetadata;
+  }
+});
+Object.defineProperty(exports, 'extractModuleMetadata', {
+  enumerable: true,
+  get: function () {
+    return extractModuleMetadata;
+  }
+});
+Object.defineProperty(exports, 'getAllEndpointMetadata', {
+  enumerable: true,
+  get: function () {
+    return getAllEndpointMetadata;
+  }
+});
+Object.defineProperty(exports, 'getControllerMetadata', {
+  enumerable: true,
+  get: function () {
+    return getControllerMetadata;
+  }
+});
+Object.defineProperty(exports, 'getEndpointMetadata', {
+  enumerable: true,
+  get: function () {
+    return getEndpointMetadata;
+  }
+});
+Object.defineProperty(exports, 'getModuleMetadata', {
+  enumerable: true,
+  get: function () {
+    return getModuleMetadata;
+  }
+});
+Object.defineProperty(exports, 'hasControllerMetadata', {
+  enumerable: true,
+  get: function () {
+    return hasControllerMetadata;
+  }
+});
+Object.defineProperty(exports, 'hasModuleMetadata', {
+  enumerable: true,
+  get: function () {
+    return hasModuleMetadata;
+  }
+});
+//# sourceMappingURL=use-guards.decorator-DdvUhB03.cjs.map