@vercube/auth 0.0.1-beta.0 → 0.0.1-beta.1

package/dist/Decorators/{Authenticate.d.ts → Auth.d.ts}

@@ -1,7 +1,7 @@
-import { AuthenticationTypes } from "../Types/AuthenticationTypes.js";
+import type { AuthTypes } from "../Types/AuthTypes.js";
 /**
 * Authentication decorator that adds middleware to protect routes or controllers
 * @param options Optional options for the authentication middleware
 * @returns A decorator function that adds authentication middleware to the target
 */
-export declare function Authenticate(options?: AuthenticationTypes.MiddlewareOptions): Function;
+export declare function Auth(options?: AuthTypes.MiddlewareOptions): Function;

package/dist/Decorators/User.d.ts

@@ -0,0 +1,32 @@
+import { AuthProvider } from "../Services/AuthProvider.js";
+/**
+* Options for the User decorator
+* @interface UserDecoratorOptions
+*/
+interface UserDecoratorOptions {
+	/**
+	* Optional custom auth provider to use for retrieving the current user
+	* If not provided, the default AuthProvider will be used
+	*/
+	provider?: typeof AuthProvider;
+}
+/**
+* Creates a decorator that injects the current user into controller methods
+* 
+* @param {UserDecoratorOptions} [params] - Optional configuration for the decorator
+* @returns {Function} A decorator function that can be applied to controller method parameters
+* 
+* @example
+* // Basic usage
+* async someMethod(@User() user: User) {
+*   // user is automatically injected
+* }
+* 
+* @example
+* // With custom provider
+* async someMethod(@User() user: User) {
+*   // user is retrieved using CustomAuthProvider
+* }
+*/
+export declare function User(params?: UserDecoratorOptions): Function;
+export {};

package/dist/Middleware/{AuthenticationMiddleware.d.ts → AuthMiddleware.d.ts}

@@ -1,18 +1,17 @@
 import { type BaseMiddleware, type MiddlewareOptions } from "@vercube/core";
-import { AuthenticationTypes } from "../Types/AuthenticationTypes.js";
+import type { AuthTypes } from "../Types/AuthTypes.js";
 /**
-* Middleware for authentication
-* @class AuthenticationMiddleware
+* Middleware for auth
 * @implements {BaseMiddleware}
-* @description Authenticates incoming request
+* @description authorizes incoming request
 * @example
-* const middleware = new AuthenticationMiddleware();
+* const middleware = new AuthMiddleware();
 * await middleware.use(event);
 */
-export declare class AuthenticationMiddleware implements BaseMiddleware<AuthenticationTypes.MiddlewareOptions> {
+export declare class AuthMiddleware implements BaseMiddleware<AuthTypes.MiddlewareOptions> {
 	private gContainer;
-	private gAuthenticationProvider;
 	private gLogger;
+	private gAuthProvider;
 	/**
 	* Middleware function that processes the HTTP event.
 	*
@@ -21,5 +20,5 @@ export declare class AuthenticationMiddleware implements BaseMiddleware<Authenti
 	* @param {MiddlewareOptions} args - Additional arguments for the middleware
 	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
 	*/
-	onRequest(request: Request, response: Response, args: MiddlewareOptions<AuthenticationTypes.MiddlewareOptions>): Promise<void>;
+	onRequest(request: Request, response: Response, args: MiddlewareOptions<AuthTypes.MiddlewareOptions>): Promise<void>;
 }

package/dist/Services/AuthProvider.d.ts

@@ -0,0 +1,23 @@
+/**
+* Abstract class representing an authorization provider
+* Provides a common interface for different authorization implementations
+*
+* @abstract
+* @class AuthorizationProvider
+*/
+import { AuthTypes } from "../Types/AuthTypes.js";
+export declare abstract class AuthProvider<U = unknown> {
+	/**
+	* Validate authentication
+	* @param {Request} request - The request object
+	* @param {AuthTypes.MiddlewareOptions} params - Additional parameters
+	* @returns An error string or Promise of error string, null or Promise of null if authentication is successful
+	*/
+	abstract validate(request: Request, params?: AuthTypes.MiddlewareOptions): Promise<string | null> | string | null;
+	/**
+	* Get current user
+	* @param {Request} request - The request object
+	* @returns A promise of the current user or null if no user is authenticated
+	*/
+	abstract getCurrentUser(request: Request): Promise<U | null> | U | null;
+}

package/dist/Types/AuthTypes.d.ts

@@ -0,0 +1,15 @@
+import { AuthProvider } from "../Services/AuthProvider.js";
+export declare namespace AuthTypes {
+	interface MiddlewareOptions {
+		/**
+		* Roles to authorize
+		* @default []
+		*/
+		roles?: string[];
+		/**
+		* Override provider to use for authorization
+		* Default one is set inside of the IOC container
+		*/
+		provider?: typeof AuthProvider;
+	}
+}

package/dist/index.cjs

@@ -28,8 +28,8 @@ const __vercube_core = __toESM(require("@vercube/core"));
 const __vercube_di = __toESM(require("@vercube/di"));
 const __vercube_logger = __toESM(require("@vercube/logger"));
 
-//#region packages/auth/src/Services/AuthenticationProvider.ts
-var AuthenticationProvider = class {};
+//#region packages/auth/src/Services/AuthProvider.ts
+var AuthProvider = class {};
 
 //#endregion
 //#region node_modules/.pnpm/@oxc-project+runtime@0.63.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
@@ -45,11 +45,11 @@ var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.6
 var import_decorate = __toESM(require_decorate(), 1);
 
 //#endregion
-//#region packages/auth/src/Middleware/AuthenticationMiddleware.ts
-var AuthenticationMiddleware = class {
+//#region packages/auth/src/Middleware/AuthMiddleware.ts
+var AuthMiddleware = class {
 	gContainer;
-	gAuthenticationProvider;
 	gLogger;
+	gAuthProvider;
 	/**
 	* Middleware function that processes the HTTP event.
 	*
@@ -59,90 +59,65 @@ var AuthenticationMiddleware = class {
 	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
 	*/
 	async onRequest(request, response, args) {
-		let provider = this.gAuthenticationProvider;
+		let provider = this.gAuthProvider;
 		if (args?.middlewareArgs?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.provider);
 		if (!provider) {
-			this.gLogger?.warn("AuthenticationMiddleware::AuthenticationProvider is not registered");
+			this.gLogger?.warn("AuthMiddleware::AuthProvider is not registered");
 			return;
 		}
-		const authenticationError = await provider.authenticate(request);
+		const authenticationError = await provider.validate(request, args.middlewareArgs);
 		if (authenticationError) throw new __vercube_core.UnauthorizedError(authenticationError);
 	}
 };
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], AuthenticationMiddleware.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(AuthenticationProvider)], AuthenticationMiddleware.prototype, "gAuthenticationProvider", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], AuthenticationMiddleware.prototype, "gLogger", void 0);
+(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], AuthMiddleware.prototype, "gContainer", void 0);
+(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], AuthMiddleware.prototype, "gLogger", void 0);
+(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(AuthProvider)], AuthMiddleware.prototype, "gAuthProvider", void 0);
 
 //#endregion
-//#region packages/auth/src/Decorators/Authenticate.ts
-function Authenticate(options) {
+//#region packages/auth/src/Decorators/Auth.ts
+function Auth(options) {
 	return function internalDecorator(target, propertyName) {
 		const meta = (0, __vercube_core.initializeMetadata)(propertyName ? target : target.prototype);
 		if (propertyName) (0, __vercube_core.initializeMetadataMethod)(target, propertyName);
 		meta.__middlewares.push({
 			target: propertyName ?? "__global__",
 			priority: -999,
-			middleware: AuthenticationMiddleware,
+			middleware: AuthMiddleware,
 			args: { ...options }
 		});
 	};
 }
 
 //#endregion
-//#region packages/auth/src/Services/AuthorizationProvider.ts
-var AuthorizationProvider = class {};
-
-//#endregion
-//#region packages/auth/src/Middleware/AuthorizationMiddleware.ts
-var AuthorizationMiddleware = class {
+//#region packages/auth/src/Decorators/User.ts
+var UserDecorator = class extends __vercube_di.BaseDecorator {
 	gContainer;
-	gAuthorizationProvider;
-	gLogger;
 	/**
-	* Middleware function that processes the HTTP event.
-	*
-	* @param {Request} request - The HTTP request event.
-	* @param {Response} response - The HTTP response event.
-	* @param {MiddlewareOptions} args - Additional arguments for the middleware
-	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
+	* Called when the decorator is created.
+	* Initializes metadata for the property and adds parameter information
+	* to handle user injection in controller methods.
 	*/
-	async onRequest(request, response, args) {
-		let provider = this.gAuthorizationProvider;
-		if (args.middlewareArgs?.options?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.options.provider);
-		if (!provider) {
-			this.gLogger?.warn("AuthorizationMiddleware::AuthorizationProvider is not registered");
-			return;
-		}
-		const authorizationError = await provider.authorize(request, args.middlewareArgs.params);
-		if (authorizationError) throw new __vercube_core.ForbiddenError(authorizationError);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], AuthorizationMiddleware.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(AuthorizationProvider)], AuthorizationMiddleware.prototype, "gAuthorizationProvider", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], AuthorizationMiddleware.prototype, "gLogger", void 0);
-
-//#endregion
-//#region packages/auth/src/Decorators/Authorize.ts
-function Authorize(params, options) {
-	return function internalDecorator(target, propertyName) {
-		const meta = (0, __vercube_core.initializeMetadata)(propertyName ? target : target.prototype);
-		if (propertyName) (0, __vercube_core.initializeMetadataMethod)(target, propertyName);
-		meta.__middlewares.push({
-			target: propertyName ?? "__global__",
-			priority: -998,
-			middleware: AuthorizationMiddleware,
-			args: {
-				params,
-				options
+	created() {
+		(0, __vercube_core.initializeMetadata)(this.prototype);
+		const method = (0, __vercube_core.initializeMetadataMethod)(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "custom",
+			resolver: async (event) => {
+				const provider = this.options?.provider ? this.gContainer.getOptional(this.options.provider) : this.gContainer.getOptional(AuthProvider);
+				if (!provider) return null;
+				return provider.getCurrentUser(event.request);
 			}
 		});
-	};
+	}
+};
+(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], UserDecorator.prototype, "gContainer", void 0);
+function User(params) {
+	return (0, __vercube_di.createDecorator)(UserDecorator, params);
 }
 
 //#endregion
-exports.Authenticate = Authenticate
-exports.AuthenticationMiddleware = AuthenticationMiddleware
-exports.AuthenticationProvider = AuthenticationProvider
-exports.AuthorizationMiddleware = AuthorizationMiddleware
-exports.AuthorizationProvider = AuthorizationProvider
-exports.Authorize = Authorize
+exports.Auth = Auth
+exports.AuthMiddleware = AuthMiddleware
+exports.AuthProvider = AuthProvider
+exports.User = User

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-export * from "./Decorators/Authenticate.js";
-export * from "./Decorators/Authorize.js";
-export * from "./Middleware/AuthenticationMiddleware.js";
-export * from "./Middleware/AuthorizationMiddleware.js";
-export * from "./Services/AuthenticationProvider.js";
-export * from "./Services/AuthorizationProvider.js";
+export * from "./Decorators/Auth.js";
+export * from "./Decorators/User.js";
+export * from "./Middleware/AuthMiddleware.js";
+export * from "./Services/AuthProvider.js";
+export * from "./Types/AuthTypes.js";

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { ForbiddenError, UnauthorizedError, initializeMetadata, initializeMetadataMethod } from "@vercube/core";
-import { Container, Inject, InjectOptional } from "@vercube/di";
+import { UnauthorizedError, initializeMetadata, initializeMetadataMethod } from "@vercube/core";
+import { BaseDecorator, Container, Inject, InjectOptional, createDecorator } from "@vercube/di";
 import { Logger } from "@vercube/logger";
 
-//#region packages/auth/src/Services/AuthenticationProvider.ts
-var AuthenticationProvider = class {};
+//#region packages/auth/src/Services/AuthProvider.ts
+var AuthProvider = class {};
 
 //#endregion
 //#region node_modules/.pnpm/@oxc-project+runtime@0.63.0/node_modules/@oxc-project/runtime/src/helpers/esm/decorate.js
@@ -15,11 +15,11 @@ function __decorate(decorators, target, key, desc) {
 }
 
 //#endregion
-//#region packages/auth/src/Middleware/AuthenticationMiddleware.ts
-var AuthenticationMiddleware = class {
+//#region packages/auth/src/Middleware/AuthMiddleware.ts
+var AuthMiddleware = class {
 	gContainer;
-	gAuthenticationProvider;
 	gLogger;
+	gAuthProvider;
 	/**
 	* Middleware function that processes the HTTP event.
 	*
@@ -29,85 +29,62 @@ var AuthenticationMiddleware = class {
 	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
 	*/
 	async onRequest(request, response, args) {
-		let provider = this.gAuthenticationProvider;
+		let provider = this.gAuthProvider;
 		if (args?.middlewareArgs?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.provider);
 		if (!provider) {
-			this.gLogger?.warn("AuthenticationMiddleware::AuthenticationProvider is not registered");
+			this.gLogger?.warn("AuthMiddleware::AuthProvider is not registered");
 			return;
 		}
-		const authenticationError = await provider.authenticate(request);
+		const authenticationError = await provider.validate(request, args.middlewareArgs);
 		if (authenticationError) throw new UnauthorizedError(authenticationError);
 	}
 };
-__decorate([Inject(Container)], AuthenticationMiddleware.prototype, "gContainer", void 0);
-__decorate([InjectOptional(AuthenticationProvider)], AuthenticationMiddleware.prototype, "gAuthenticationProvider", void 0);
-__decorate([InjectOptional(Logger)], AuthenticationMiddleware.prototype, "gLogger", void 0);
+__decorate([Inject(Container)], AuthMiddleware.prototype, "gContainer", void 0);
+__decorate([InjectOptional(Logger)], AuthMiddleware.prototype, "gLogger", void 0);
+__decorate([InjectOptional(AuthProvider)], AuthMiddleware.prototype, "gAuthProvider", void 0);
 
 //#endregion
-//#region packages/auth/src/Decorators/Authenticate.ts
-function Authenticate(options) {
+//#region packages/auth/src/Decorators/Auth.ts
+function Auth(options) {
 	return function internalDecorator(target, propertyName) {
 		const meta = initializeMetadata(propertyName ? target : target.prototype);
 		if (propertyName) initializeMetadataMethod(target, propertyName);
 		meta.__middlewares.push({
 			target: propertyName ?? "__global__",
 			priority: -999,
-			middleware: AuthenticationMiddleware,
+			middleware: AuthMiddleware,
 			args: { ...options }
 		});
 	};
 }
 
 //#endregion
-//#region packages/auth/src/Services/AuthorizationProvider.ts
-var AuthorizationProvider = class {};
-
-//#endregion
-//#region packages/auth/src/Middleware/AuthorizationMiddleware.ts
-var AuthorizationMiddleware = class {
+//#region packages/auth/src/Decorators/User.ts
+var UserDecorator = class extends BaseDecorator {
 	gContainer;
-	gAuthorizationProvider;
-	gLogger;
 	/**
-	* Middleware function that processes the HTTP event.
-	*
-	* @param {Request} request - The HTTP request event.
-	* @param {Response} response - The HTTP response event.
-	* @param {MiddlewareOptions} args - Additional arguments for the middleware
-	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
+	* Called when the decorator is created.
+	* Initializes metadata for the property and adds parameter information
+	* to handle user injection in controller methods.
 	*/
-	async onRequest(request, response, args) {
-		let provider = this.gAuthorizationProvider;
-		if (args.middlewareArgs?.options?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.options.provider);
-		if (!provider) {
-			this.gLogger?.warn("AuthorizationMiddleware::AuthorizationProvider is not registered");
-			return;
-		}
-		const authorizationError = await provider.authorize(request, args.middlewareArgs.params);
-		if (authorizationError) throw new ForbiddenError(authorizationError);
-	}
-};
-__decorate([Inject(Container)], AuthorizationMiddleware.prototype, "gContainer", void 0);
-__decorate([InjectOptional(AuthorizationProvider)], AuthorizationMiddleware.prototype, "gAuthorizationProvider", void 0);
-__decorate([InjectOptional(Logger)], AuthorizationMiddleware.prototype, "gLogger", void 0);
-
-//#endregion
-//#region packages/auth/src/Decorators/Authorize.ts
-function Authorize(params, options) {
-	return function internalDecorator(target, propertyName) {
-		const meta = initializeMetadata(propertyName ? target : target.prototype);
-		if (propertyName) initializeMetadataMethod(target, propertyName);
-		meta.__middlewares.push({
-			target: propertyName ?? "__global__",
-			priority: -998,
-			middleware: AuthorizationMiddleware,
-			args: {
-				params,
-				options
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "custom",
+			resolver: async (event) => {
+				const provider = this.options?.provider ? this.gContainer.getOptional(this.options.provider) : this.gContainer.getOptional(AuthProvider);
+				if (!provider) return null;
+				return provider.getCurrentUser(event.request);
 			}
 		});
-	};
+	}
+};
+__decorate([Inject(Container)], UserDecorator.prototype, "gContainer", void 0);
+function User(params) {
+	return createDecorator(UserDecorator, params);
 }
 
 //#endregion
-export { Authenticate, AuthenticationMiddleware, AuthenticationProvider, AuthorizationMiddleware, AuthorizationProvider, Authorize };
+export { Auth, AuthMiddleware, AuthProvider, User };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/auth",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.1",
   "description": "Auth module for Vercube framework",
   "repository": "@vercube/auth",
   "license": "MIT",
@@ -20,9 +20,9 @@
     "dist"
   ],
   "dependencies": {
-    "@vercube/core": "0.0.1-beta.0",
-    "@vercube/di": "0.0.1-beta.0",
-    "@vercube/logger": "0.0.1-beta.0"
+    "@vercube/core": "0.0.1-beta.1",
+    "@vercube/di": "0.0.1-beta.1",
+    "@vercube/logger": "0.0.1-beta.1"
   },
   "publishConfig": {
     "access": "public"

package/dist/Decorators/Authorize.d.ts

@@ -1,8 +0,0 @@
-import { AuthorizationTypes } from "../Types/AuthorizationTypes.js";
-/**
-* Authorization decorator that adds middleware to protect routes or controllers
-* @param params Parameters for the authorization middleware
-* @param options Optional options for the authorization middleware
-* @returns A decorator function that adds authorization middleware to the target
-*/
-export declare function Authorize<T>(params: T, options?: AuthorizationTypes.MiddlewareOptions<T>): Function;

package/dist/Middleware/AuthorizationMiddleware.d.ts

@@ -1,28 +0,0 @@
-import { type BaseMiddleware, type MiddlewareOptions } from "@vercube/core";
-import { AuthorizationTypes } from "../Types/AuthorizationTypes.js";
-/**
-* Middleware for authorization
-* @class AuthorizationMiddleware
-* @implements {BaseMiddleware}
-* @description Authorizes incoming request
-* @example
-* const middleware = new AuthorizationMiddleware<UserType>();
-* await middleware.use(event, args);
-*/
-export declare class AuthorizationMiddleware<T> implements BaseMiddleware {
-	private gContainer;
-	private gAuthorizationProvider;
-	private gLogger;
-	/**
-	* Middleware function that processes the HTTP event.
-	*
-	* @param {Request} request - The HTTP request event.
-	* @param {Response} response - The HTTP response event.
-	* @param {MiddlewareOptions} args - Additional arguments for the middleware
-	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
-	*/
-	onRequest(request: Request, response: Response, args: MiddlewareOptions<{
-		options: AuthorizationTypes.MiddlewareOptions
-		params: T
-	}>): Promise<void>;
-}

package/dist/Services/AuthenticationProvider.d.ts

@@ -1,15 +0,0 @@
-/**
-* Abstract class representing an authentication provider
-* Provides a common interface for different authentication implementations
-*
-* @abstract
-* @class AuthenticationProvider
-*/
-export declare abstract class AuthenticationProvider {
-	/**
-	* Authenticates based on the HTTP event
-	* @param request - The HTTP event containing the request
-	* @returns An error string or Promise of error string, null or Promise of null if authentication is successful
-	*/
-	abstract authenticate(request: Request): Promise<string | null> | string | null;
-}

package/dist/Services/AuthorizationProvider.d.ts

@@ -1,16 +0,0 @@
-/**
-* Abstract class representing an authorization provider
-* Provides a common interface for different authorization implementations
-*
-* @abstract
-* @class AuthorizationProvider
-*/
-export declare abstract class AuthorizationProvider<T> {
-	/**
-	* Authorizes based on given params
-	* @param {Request} request - The request object
-	* @param {T} params - Additional parameters
-	* @returns An error string or Promise of error string, null or Promise of null if authentication is successful
-	*/
-	abstract authorize(request: Request, params: T): Promise<string | null> | string | null;
-}