@vercube/auth 0.0.1-alpha.15

package/dist/Decorators/Authenticate.d.ts

@@ -0,0 +1,7 @@
+import { AuthenticationTypes } from "../Types/AuthenticationTypes.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;

package/dist/Decorators/Authorize.d.ts

@@ -0,0 +1,8 @@
+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/AuthenticationMiddleware.d.ts

@@ -0,0 +1,24 @@
+import { type BaseMiddleware, type MiddlewareOptions } from "@vercube/core";
+import { AuthenticationTypes } from "../Types/AuthenticationTypes.js";
+/**
+* Middleware for authentication
+* @class AuthenticationMiddleware
+* @implements {BaseMiddleware}
+* @description Authenticates incoming request
+* @example
+* const middleware = new AuthenticationMiddleware();
+* await middleware.use(event);
+*/
+export declare class AuthenticationMiddleware implements BaseMiddleware<AuthenticationTypes.MiddlewareOptions> {
+	private gContainer;
+	private gAuthenticationProvider;
+	/**
+	* Middleware function that processes the HTTP event.
+	*
+	* @param {Request} request - The HTTP request to be processed
+	* @param {Response} response - The HTTP response to be processed
+	* @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>;
+}

package/dist/Middleware/AuthorizationMiddleware.d.ts

@@ -0,0 +1,27 @@
+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;
+	/**
+	* 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

@@ -0,0 +1,15 @@
+/**
+* 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

@@ -0,0 +1,16 @@
+/**
+* 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;
+}

package/dist/index.cjs

@@ -0,0 +1,143 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __vercube_core = __toESM(require("@vercube/core"));
+const __vercube_di = __toESM(require("@vercube/di"));
+
+//#region packages/auth/src/Services/AuthenticationProvider.ts
+var AuthenticationProvider = class {};
+
+//#endregion
+//#region node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+	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;
+	}
+	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_decorate = __toESM(require_decorate(), 1);
+
+//#endregion
+//#region packages/auth/src/Middleware/AuthenticationMiddleware.ts
+var AuthenticationMiddleware = class {
+	gContainer;
+	gAuthenticationProvider;
+	/**
+	* Middleware function that processes the HTTP event.
+	*
+	* @param {Request} request - The HTTP request to be processed
+	* @param {Response} response - The HTTP response to be processed
+	* @param {MiddlewareOptions} args - Additional arguments for the middleware
+	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
+	*/
+	async onRequest(request, response, args) {
+		let provider = this.gAuthenticationProvider;
+		if (args?.middlewareArgs?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.provider);
+		if (!provider) {
+			console.warn("AuthenticationMiddleware::AuthenticationProvider is not registered");
+			return;
+		}
+		const authenticationError = await provider.authenticate(request);
+		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);
+
+//#endregion
+//#region packages/auth/src/Decorators/Authenticate.ts
+function Authenticate(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,
+			args: { ...options }
+		});
+	};
+}
+
+//#endregion
+//#region packages/auth/src/Services/AuthorizationProvider.ts
+var AuthorizationProvider = class {};
+
+//#endregion
+//#region packages/auth/src/Middleware/AuthorizationMiddleware.ts
+var AuthorizationMiddleware = class {
+	gContainer;
+	gAuthorizationProvider;
+	/**
+	* 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.
+	*/
+	async onRequest(request, response, args) {
+		let provider = this.gAuthorizationProvider;
+		if (args.middlewareArgs?.options?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.options.provider);
+		if (!provider) {
+			console.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);
+
+//#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
+			}
+		});
+	};
+}
+
+//#endregion
+exports.Authenticate = Authenticate
+exports.AuthenticationMiddleware = AuthenticationMiddleware
+exports.AuthenticationProvider = AuthenticationProvider
+exports.AuthorizationMiddleware = AuthorizationMiddleware
+exports.AuthorizationProvider = AuthorizationProvider
+exports.Authorize = Authorize

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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";

package/dist/index.mjs

@@ -0,0 +1,108 @@
+import { ForbiddenError, UnauthorizedError, initializeMetadata, initializeMetadataMethod } from "@vercube/core";
+import { Container, Inject, InjectOptional } from "@vercube/di";
+
+//#region packages/auth/src/Services/AuthenticationProvider.ts
+var AuthenticationProvider = class {};
+
+//#endregion
+//#region node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/helpers/esm/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 packages/auth/src/Middleware/AuthenticationMiddleware.ts
+var AuthenticationMiddleware = class {
+	gContainer;
+	gAuthenticationProvider;
+	/**
+	* Middleware function that processes the HTTP event.
+	*
+	* @param {Request} request - The HTTP request to be processed
+	* @param {Response} response - The HTTP response to be processed
+	* @param {MiddlewareOptions} args - Additional arguments for the middleware
+	* @returns {Promise<void>} - A promise that resolves when the processing is complete.
+	*/
+	async onRequest(request, response, args) {
+		let provider = this.gAuthenticationProvider;
+		if (args?.middlewareArgs?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.provider);
+		if (!provider) {
+			console.warn("AuthenticationMiddleware::AuthenticationProvider is not registered");
+			return;
+		}
+		const authenticationError = await provider.authenticate(request);
+		if (authenticationError) throw new UnauthorizedError(authenticationError);
+	}
+};
+__decorate([Inject(Container)], AuthenticationMiddleware.prototype, "gContainer", void 0);
+__decorate([InjectOptional(AuthenticationProvider)], AuthenticationMiddleware.prototype, "gAuthenticationProvider", void 0);
+
+//#endregion
+//#region packages/auth/src/Decorators/Authenticate.ts
+function Authenticate(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,
+			args: { ...options }
+		});
+	};
+}
+
+//#endregion
+//#region packages/auth/src/Services/AuthorizationProvider.ts
+var AuthorizationProvider = class {};
+
+//#endregion
+//#region packages/auth/src/Middleware/AuthorizationMiddleware.ts
+var AuthorizationMiddleware = class {
+	gContainer;
+	gAuthorizationProvider;
+	/**
+	* 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.
+	*/
+	async onRequest(request, response, args) {
+		let provider = this.gAuthorizationProvider;
+		if (args.middlewareArgs?.options?.provider) provider = this.gContainer.getOptional(args.middlewareArgs.options.provider);
+		if (!provider) {
+			console.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);
+
+//#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
+			}
+		});
+	};
+}
+
+//#endregion
+export { Authenticate, AuthenticationMiddleware, AuthenticationProvider, AuthorizationMiddleware, AuthorizationProvider, Authorize };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vercube/auth",
+  "version": "0.0.1-alpha.15",
+  "description": "Auth module for Vercube framework",
+  "repository": "@vercube/auth",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vercube/di": "0.0.1-alpha.15",
+    "@vercube/core": "0.0.1-alpha.15"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}