arkos 0.1.27-beta.1 → 0.2.0-beta.1

package/dist/cjs/exports/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/exports/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sCAAoC;AAQpC,MAAM,KAAK,GAAG;IACZ,IAAI,EAAE,gBAAO;CACd,CAAC;AAOF,6CAA2B;AAC3B,0CAAwB;AACxB,+CAA6B;AAC7B,kDAAgC;AAEhC,kBAAe,KAAK,CAAC","sourcesContent":["import { initApp } from \"../server\";\r\n\r\n/**\r\n * Initializes the Arkos application.\r\n *\r\n * @module arkos\r\n * @property {Function} init - Function to initialize the app.\r\n */\r\nconst arkos = {\r\n  init: initApp,\r\n};\r\n\r\n/**\r\n * Main entry point for the Arkos module.\r\n *\r\n * @module arkos\r\n */\r\nexport * from \"./services\";\r\nexport * from \"./utils\";\r\nexport * from \"./validation\";\r\nexport * from \"./error-handler\";\r\n\r\nexport default arkos;\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/exports/index.ts"],"names":[],"mappings":";;AAAA,sCAAoC;AAcpC,MAAM,KAAK,GAAG;IACZ,IAAI,EAAE,gBAAO;CACd,CAAC;AASF,kBAAe,KAAK,CAAC","sourcesContent":["import { initApp } from \"../server\";\nimport {\n  ArkosRequest,\n  ArkosResponse,\n  ArkosNextFunction,\n  ArkosRequestHandler,\n} from \"../types\";\n\n/**\n * Initializes the Arkos application.\n *\n * @module arkos\n * @property {Function} init - Function to initialize the app.\n */\nconst arkos = {\n  init: initApp,\n};\n\nexport { ArkosRequest, ArkosResponse, ArkosNextFunction, ArkosRequestHandler };\n\n/**\n * Main entry point for the Arkos module.\n *\n * @module arkos\n */\nexport default arkos;\n\n// export * from \"./services\";\n// export * from \"./utils\";\n// export * from \"./validation\";\n// export * from \"./error-handler\";\n"]}

package/dist/cjs/exports/prisma/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/cjs/exports/prisma/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/prisma/index.ts"],"names":[],"mappings":"","sourcesContent":["import { PrismaQueryOptions } from \"./../../types/index.d\";\n\nexport { PrismaQueryOptions };\n"]}

package/dist/cjs/exports/services/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,mFAA0D;AAajD,sBAbF,sBAAW,CAaE;AAZpB,mFAA+E;AAsBtE,uBAtBF,uBAAY,CAsBE;AAAE,6FAtBA,4BAAY,OAsBA;AArBnC,6FAK2D;AAsBzD,qGA1BA,4CAAoB,OA0BA;AACpB,wGA1BA,+CAAuB,OA0BA;AACvB,qGA1BA,4CAAoB,OA0BA;AACpB,oGA1BA,2CAAmB,OA0BA;AAxBrB,kEAA+E;AAUtE,4FAVA,0BAAW,OAUA;AAAE,gGAVA,8BAAe,OAUA","sourcesContent":["import { EmailOptions } from \"../../modules/email/email.service\";\r\nimport authService from \"../../modules/auth/auth.service\";\r\nimport emailService, { EmailService } from \"../../modules/email/email.service\";\r\nimport {\r\n  imageUploaderService,\r\n  documentUploaderService,\r\n  videoUploaderService,\r\n  fileUploaderService,\r\n} from \"../../modules/file-uploader/file-uploader.service\";\r\nimport { BaseService, getBaseServices } from \"../../modules/base/base.service\";\r\n\r\n/**\r\n * Authentication service.\r\n */\r\nexport { authService };\r\n\r\n/**\r\n * Base service.\r\n */\r\nexport { BaseService, getBaseServices };\r\n\r\n/**\r\n * Email service.\r\n */\r\nexport { emailService, EmailService, EmailOptions };\r\n\r\n/**\r\n * File upload services.\r\n */\r\nexport {\r\n  imageUploaderService,\r\n  documentUploaderService,\r\n  videoUploaderService,\r\n  fileUploaderService,\r\n};\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,mFAA0D;AAajD,sBAbF,sBAAW,CAaE;AAZpB,mFAA+E;AAsBtE,uBAtBF,uBAAY,CAsBE;AAAE,6FAtBA,4BAAY,OAsBA;AArBnC,6FAK2D;AAsBzD,qGA1BA,4CAAoB,OA0BA;AACpB,wGA1BA,+CAAuB,OA0BA;AACvB,qGA1BA,4CAAoB,OA0BA;AACpB,oGA1BA,2CAAmB,OA0BA;AAxBrB,kEAA+E;AAUtE,4FAVA,0BAAW,OAUA;AAAE,gGAVA,8BAAe,OAUA","sourcesContent":["import { EmailOptions } from \"../../modules/email/email.service\";\nimport authService from \"../../modules/auth/auth.service\";\nimport emailService, { EmailService } from \"../../modules/email/email.service\";\nimport {\n  imageUploaderService,\n  documentUploaderService,\n  videoUploaderService,\n  fileUploaderService,\n} from \"../../modules/file-uploader/file-uploader.service\";\nimport { BaseService, getBaseServices } from \"../../modules/base/base.service\";\n\n/**\n * Authentication service.\n */\nexport { authService };\n\n/**\n * Base service.\n */\nexport { BaseService, getBaseServices };\n\n/**\n * Email service.\n */\nexport { emailService, EmailService, EmailOptions };\n\n/**\n * File upload services.\n */\nexport {\n  imageUploaderService,\n  documentUploaderService,\n  videoUploaderService,\n  fileUploaderService,\n};\n"]}

package/dist/cjs/exports/utils/change-case.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../utils/features/change-case.features"), exports);
+//# sourceMappingURL=change-case.js.map

package/dist/cjs/exports/utils/change-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-case.js","sourceRoot":"","sources":["../../../../src/exports/utils/change-case.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4EAA0D","sourcesContent":["export * from \"../../utils/features/change-case.features\";\n"]}

package/dist/cjs/exports/utils/index.js

@@ -1,13 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrismaModels = exports.capitalize = exports.utils = void 0;
-const text_helpers_1 = require("../../utils/helpers/text.helpers");
-Object.defineProperty(exports, "capitalize", { enumerable: true, get: function () { return text_helpers_1.capitalize; } });
+exports.getPrismaModels = void 0;
 const models_helpers_1 = require("../../utils/helpers/models.helpers");
 Object.defineProperty(exports, "getPrismaModels", { enumerable: true, get: function () { return models_helpers_1.getModels; } });
-exports.utils = {
-    capitalize: text_helpers_1.capitalize,
-    getPrismaModels: models_helpers_1.getModels,
-};
-exports.default = exports.utils;
 //# sourceMappingURL=index.js.map

package/dist/cjs/exports/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/utils/index.ts"],"names":[],"mappings":";;;AAAA,mEAA8D;AAerD,2FAfA,yBAAU,OAeA;AAdnB,uEAA+D;AAc7B,gGAdzB,0BAAS,OAc+B;AALpC,QAAA,KAAK,GAAG;IACnB,UAAU,EAAV,yBAAU;IACV,eAAe,EAAE,0BAAS;CAC3B,CAAC;AAGF,kBAAe,aAAK,CAAC","sourcesContent":["import { capitalize } from \"../../utils/helpers/text.helpers\";\r\nimport { getModels } from \"../../utils/helpers/models.helpers\";\r\n\r\n/**\r\n * A collection of utility functions.\r\n *\r\n * @namespace utils\r\n * @property {Function} capitalize - Capitalizes the first letter of each word in a string.\r\n * @property {Function} getPrismaModels - Retrieves Prisma models dynamically.\r\n */\r\nexport const utils = {\r\n  capitalize,\r\n  getPrismaModels: getModels,\r\n};\r\n\r\nexport { capitalize, getModels as getPrismaModels };\r\nexport default utils;\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/utils/index.ts"],"names":[],"mappings":";;;AAAA,uEAA+D;AAEzC,gGAFb,0BAAS,OAEmB","sourcesContent":["import { getModels } from \"../../utils/helpers/models.helpers\";\n\nexport { getModels as getPrismaModels };\n"]}

package/dist/cjs/exports/validation/index.js

@@ -3,11 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDto = exports.validation = void 0;
+exports.validateDto = void 0;
 const validate_dto_1 = __importDefault(require("../../utils/validate-dto"));
 exports.validateDto = validate_dto_1.default;
-exports.validation = {
-    validateDto: validate_dto_1.default,
-};
-exports.default = exports.validation;
 //# sourceMappingURL=index.js.map

package/dist/cjs/exports/validation/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/validation/index.ts"],"names":[],"mappings":";;;;;;AAAA,4EAAmD;AAY1C,sBAZF,sBAAW,CAYE;AAJP,QAAA,UAAU,GAAG;IACxB,WAAW,EAAX,sBAAW;CACZ,CAAC;AAGF,kBAAe,kBAAU,CAAC","sourcesContent":["import validateDto from \"../../utils/validate-dto\";\r\n\r\n/**\r\n * A collection of validation utilities.\r\n *\r\n * @namespace validation\r\n * @property {Function} validateDto - Validates data transfer objects (DTO).\r\n */\r\nexport const validation = {\r\n  validateDto,\r\n};\r\n\r\nexport { validateDto };\r\nexport default validation;\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/exports/validation/index.ts"],"names":[],"mappings":";;;;;;AAAA,4EAAmD;AAE1C,sBAFF,sBAAW,CAEE","sourcesContent":["import validateDto from \"../../utils/validate-dto\";\n\nexport { validateDto };\n"]}

package/dist/cjs/modules/auth/__tests__/auth.controller.test.js

@@ -0,0 +1,514 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const auth_controller_1 = require("../auth.controller");
+const auth_service_1 = __importDefault(require("../auth.service"));
+const base_service_1 = require("../../base/base.service");
+const prisma_helpers_1 = require("../../../utils/helpers/prisma.helpers");
+const models_helpers_1 = require("../../../utils/helpers/models.helpers");
+const server_1 = require("../../../server");
+vitest_1.vi.mock("bcrypt", () => ({
+    default: {
+        compare: vitest_1.vi.fn(),
+        hash: vitest_1.vi.fn(),
+    },
+}));
+vitest_1.vi.mock("../auth.service", () => ({
+    default: {
+        isCorrectPassword: vitest_1.vi.fn(),
+        signJwtToken: vitest_1.vi.fn(),
+        isPasswordStrong: vitest_1.vi.fn(),
+        hashPassword: vitest_1.vi.fn(),
+        authenticate: vitest_1.vi.fn(),
+        handleAuthenticationControl: vitest_1.vi.fn(),
+        handleActionAccessControl: vitest_1.vi.fn(),
+    },
+}));
+vitest_1.vi.mock("../../base/base.service", () => ({
+    getBaseServices: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock("../../../utils/helpers/prisma.helpers", () => ({
+    getPrismaInstance: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock("../../../utils/helpers/models.helpers", () => ({
+    importPrismaModelModules: vitest_1.vi.fn(),
+    getPrismaModelRelations: vitest_1.vi.fn(),
+    getModels: vitest_1.vi.fn(() => []),
+    getModelUniqueFields: vitest_1.vi.fn(() => []),
+    models: [],
+    prismaModelRelationFields: {},
+}));
+vitest_1.vi.mock("../../../server", () => ({
+    getInitConfigs: vitest_1.vi.fn(),
+    close: vitest_1.vi.fn(),
+}));
+(0, vitest_1.describe)("Auth Controller Factory", () => {
+    let req;
+    let res;
+    let next;
+    let mockPrisma;
+    let authController;
+    let userService;
+    (0, vitest_1.beforeEach)(() => __awaiter(void 0, void 0, void 0, function* () {
+        vitest_1.vi.resetAllMocks();
+        userService = {
+            findOne: vitest_1.vi.fn(),
+            createOne: vitest_1.vi.fn(),
+        };
+        mockPrisma = {
+            user: {
+                findUnique: vitest_1.vi.fn(),
+                update: vitest_1.vi.fn(),
+            },
+        };
+        base_service_1.getBaseServices.mockReturnValue({
+            user: userService,
+        });
+        prisma_helpers_1.getPrismaInstance.mockReturnValue(mockPrisma);
+        models_helpers_1.importPrismaModelModules.mockResolvedValue({
+            prismaQueryOptions: {
+                queryOptions: {},
+                findOne: {},
+            },
+        });
+        server_1.getInitConfigs.mockReturnValue({
+            authentication: {
+                usernameField: "username",
+                login: {
+                    sendAccessTokenThrough: "both",
+                },
+            },
+        });
+        req = {
+            user: {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: true,
+                active: true,
+            },
+            body: {},
+            query: {},
+            secure: false,
+            headers: {},
+        };
+        res = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            json: vitest_1.vi.fn(),
+            cookie: vitest_1.vi.fn(),
+            send: vitest_1.vi.fn(),
+        };
+        next = vitest_1.vi.fn();
+        authController = yield (0, auth_controller_1.authControllerFactory)();
+    }));
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.describe)("getMe", () => {
+        (0, vitest_1.it)("should get the current user and return it", () => __awaiter(void 0, void 0, void 0, function* () {
+            userService.findOne.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                email: "test@example.com",
+            });
+            yield authController.getMe(req, res, next);
+            (0, vitest_1.expect)(userService.findOne).toHaveBeenCalledWith({ id: "user-id-123" }, vitest_1.expect.any(String));
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(200);
+            (0, vitest_1.expect)(res.json).toHaveBeenCalledWith(req.user);
+        }));
+        (0, vitest_1.it)("should remove excluded fields from the user object", () => __awaiter(void 0, void 0, void 0, function* () {
+            const fullUser = {
+                id: "user-id-123",
+                username: "testuser",
+                email: "test@example.com",
+                password: "hashedPassword",
+                passwordChangedAt: new Date(),
+                active: true,
+            };
+            req.user = Object.assign({}, fullUser);
+            userService.findOne.mockResolvedValueOnce(fullUser);
+            yield authController.getMe(req, res, next);
+            Object.keys(auth_controller_1.defaultExcludedUserFields).forEach((field) => {
+                (0, vitest_1.expect)(req.user[field]).toBeUndefined();
+            });
+        }));
+        (0, vitest_1.it)("should call next middleware when afterGetMe is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const controllerWithMiddleware = yield (0, auth_controller_1.authControllerFactory)({
+                afterGetMe: true,
+            });
+            userService.findOne.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                email: "test@example.com",
+            });
+            yield controllerWithMiddleware.getMe(req, res, next);
+            (0, vitest_1.expect)(req.responseData).toBeDefined();
+            (0, vitest_1.expect)(req.responseStatus).toBe(200);
+            (0, vitest_1.expect)(next).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).not.toHaveBeenCalled();
+        }));
+    });
+    (0, vitest_1.describe)("logout", () => {
+        (0, vitest_1.it)("should clear the access token cookie and return 204", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield authController.logout(req, res, next);
+            (0, vitest_1.expect)(res.cookie).toHaveBeenCalledWith("arkos_access_token", "no-token", vitest_1.expect.objectContaining({
+                httpOnly: true,
+            }));
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(204);
+            (0, vitest_1.expect)(res.json).toHaveBeenCalled();
+        }));
+        (0, vitest_1.it)("should call next middleware when afterLogout is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const controllerWithMiddleware = yield (0, auth_controller_1.authControllerFactory)({
+                afterLogout: true,
+            });
+            yield controllerWithMiddleware.logout(req, res, next);
+            (0, vitest_1.expect)(req.responseData).toBeNull();
+            (0, vitest_1.expect)(req.responseStatus).toBe(204);
+            (0, vitest_1.expect)(next).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).not.toHaveBeenCalled();
+        }));
+    });
+    (0, vitest_1.describe)("login", () => {
+        (0, vitest_1.it)("should return 400 if username or password is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser" };
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 400,
+                message: vitest_1.expect.stringContaining("username and password"),
+            }));
+        }));
+        (0, vitest_1.it)("should use default username field from config when not specified in query", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(mockPrisma.user.findUnique).toHaveBeenCalledWith({
+                where: { username: "testuser" },
+            });
+        }));
+        (0, vitest_1.it)("should use username field from query parameter when provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.query.usernameField = "email";
+            req.body = { email: "test@example.com", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                email: "test@example.com",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(mockPrisma.user.findUnique).toHaveBeenCalledWith({
+                where: { email: "test@example.com" },
+            });
+        }));
+        (0, vitest_1.it)("should return 401 if user is not found", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "nonexistentuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce(null);
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 401,
+                message: vitest_1.expect.stringContaining("Incorrect username or password"),
+            }));
+        }));
+        (0, vitest_1.it)("should return 401 if password is incorrect", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser", password: "WrongPassword123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(false);
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 401,
+                message: vitest_1.expect.stringContaining("Incorrect username or password"),
+            }));
+        }));
+        (0, vitest_1.it)('should set cookie and return token in response when config is "both"', () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            server_1.getInitConfigs.mockReturnValue({
+                authentication: {
+                    usernameField: "username",
+                    login: {
+                        sendAccessTokenThrough: "both",
+                    },
+                },
+            });
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(res.cookie).toHaveBeenCalledWith("arkos_access_token", "jwt-token-123", vitest_1.expect.any(Object));
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(200);
+            (0, vitest_1.expect)(res.json).toHaveBeenCalledWith({
+                accessToken: "jwt-token-123",
+            });
+        }));
+        (0, vitest_1.it)('should only set cookie when config is "cookie-only"', () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            server_1.getInitConfigs.mockReturnValue({
+                authentication: {
+                    usernameField: "username",
+                    login: {
+                        sendAccessTokenThrough: "cookie-only",
+                    },
+                },
+            });
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(res.cookie).toHaveBeenCalledWith("arkos_access_token", "jwt-token-123", vitest_1.expect.any(Object));
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(200);
+            (0, vitest_1.expect)(res.send).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.json).not.toHaveBeenCalled();
+        }));
+        (0, vitest_1.it)('should only return token in response when config is "response-only"', () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { username: "testuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            server_1.getInitConfigs.mockReturnValue({
+                authentication: {
+                    usernameField: "username",
+                    login: {
+                        sendAccessTokenThrough: "response-only",
+                    },
+                },
+            });
+            yield authController.login(req, res, next);
+            (0, vitest_1.expect)(res.cookie).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(200);
+            (0, vitest_1.expect)(res.json).toHaveBeenCalledWith({
+                accessToken: "jwt-token-123",
+            });
+        }));
+        (0, vitest_1.it)("should call next middleware when afterLogin is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const controllerWithMiddleware = yield (0, auth_controller_1.authControllerFactory)({
+                afterLogin: true,
+            });
+            req.body = { username: "testuser", password: "Password123" };
+            mockPrisma.user.findUnique.mockResolvedValueOnce({
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+            });
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.signJwtToken.mockReturnValue("jwt-token-123");
+            yield controllerWithMiddleware.login(req, res, next);
+            (0, vitest_1.expect)(req.responseData).toEqual({ accessToken: "jwt-token-123" });
+            (0, vitest_1.expect)(req.responseStatus).toBe(200);
+            (0, vitest_1.expect)(next).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).not.toHaveBeenCalled();
+        }));
+    });
+    (0, vitest_1.describe)("signup", () => {
+        (0, vitest_1.it)("should create a new user and return 201", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = {
+                username: "newuser",
+                email: "newuser@example.com",
+                password: "Password123",
+            };
+            const createdUser = {
+                id: "new-user-id",
+                username: "newuser",
+                email: "newuser@example.com",
+                password: "hashedPassword",
+                active: true,
+            };
+            userService.createOne.mockResolvedValueOnce(Object.assign({}, createdUser));
+            yield authController.signup(req, res, next);
+            (0, vitest_1.expect)(userService.createOne).toHaveBeenCalledWith(req.body);
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(201);
+            const responseUser = res.json.mock.calls[0][0].data;
+            Object.keys(auth_controller_1.defaultExcludedUserFields).forEach((field) => {
+                (0, vitest_1.expect)(responseUser[field]).toBeUndefined();
+            });
+        }));
+        (0, vitest_1.it)("should call next middleware when afterSignup is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const controllerWithMiddleware = yield (0, auth_controller_1.authControllerFactory)({
+                afterSignup: true,
+            });
+            req.body = {
+                username: "newuser",
+                email: "newuser@example.com",
+                password: "Password123",
+            };
+            const createdUser = {
+                id: "new-user-id",
+                username: "newuser",
+                email: "newuser@example.com",
+                password: "hashedPassword",
+            };
+            userService.createOne.mockResolvedValueOnce(Object.assign({}, createdUser));
+            yield controllerWithMiddleware.signup(req, res, next);
+            (0, vitest_1.expect)(req.responseData).toEqual({ data: createdUser });
+            (0, vitest_1.expect)(req.responseStatus).toBe(201);
+            (0, vitest_1.expect)(next).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).not.toHaveBeenCalled();
+        }));
+    });
+    (0, vitest_1.describe)("updatePassword", () => {
+        (0, vitest_1.it)("should return 400 if currentPassword or newPassword is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.body = { currentPassword: "CurrentPassword123" };
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 400,
+                message: vitest_1.expect.stringContaining("currentPassword and newPassword are required"),
+            }));
+        }));
+        (0, vitest_1.it)("should return 404 if user is not found or inactive", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.user = null;
+            req.body = {
+                currentPassword: "CurrentPassword123",
+                newPassword: "NewPassword123",
+            };
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 404,
+                message: vitest_1.expect.stringContaining("User not found"),
+            }));
+        }));
+        (0, vitest_1.it)("should return 423 if user is not verified", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.user = {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: false,
+            };
+            req.body = {
+                currentPassword: "CurrentPassword123",
+                newPassword: "NewPassword123",
+            };
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 423,
+                message: vitest_1.expect.stringContaining("verify your account"),
+            }));
+        }));
+        (0, vitest_1.it)("should return 400 if current password is incorrect", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.user = {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: true,
+            };
+            req.body = {
+                currentPassword: "WrongPassword123",
+                newPassword: "NewPassword123",
+            };
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(false);
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 400,
+                message: vitest_1.expect.stringContaining("Current password is incorrect"),
+            }));
+        }));
+        (0, vitest_1.it)("should return 400 if new password is not strong enough", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.user = {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: true,
+            };
+            req.body = {
+                currentPassword: "CurrentPassword123",
+                newPassword: "weakpassword",
+            };
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.isPasswordStrong.mockReturnValue(false);
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(next).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                statusCode: 400,
+                message: vitest_1.expect.stringContaining("Password must contain"),
+            }));
+        }));
+        (0, vitest_1.it)("should update password and return 200 on success", () => __awaiter(void 0, void 0, void 0, function* () {
+            req.user = {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: true,
+            };
+            req.body = {
+                currentPassword: "CurrentPassword123",
+                newPassword: "NewPassword123",
+            };
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.isPasswordStrong.mockReturnValue(true);
+            auth_service_1.default.hashPassword.mockResolvedValueOnce("newHashedPassword");
+            yield authController.updatePassword(req, res, next);
+            (0, vitest_1.expect)(mockPrisma.user.update).toHaveBeenCalledWith({
+                where: { id: "user-id-123" },
+                data: {
+                    password: "newHashedPassword",
+                    passwordChangedAt: vitest_1.expect.any(Date),
+                },
+            });
+            (0, vitest_1.expect)(res.status).toHaveBeenCalledWith(200);
+            (0, vitest_1.expect)(res.json).toHaveBeenCalledWith({
+                status: "success",
+                message: "Password updated successfully!",
+            });
+        }));
+        (0, vitest_1.it)("should call next middleware when afterUpdatePassword is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const controllerWithMiddleware = yield (0, auth_controller_1.authControllerFactory)({
+                afterUpdatePassword: true,
+            });
+            req.user = {
+                id: "user-id-123",
+                username: "testuser",
+                password: "hashedPassword",
+                isVerified: true,
+            };
+            req.body = {
+                currentPassword: "CurrentPassword123",
+                newPassword: "NewPassword123",
+            };
+            auth_service_1.default.isCorrectPassword.mockResolvedValueOnce(true);
+            auth_service_1.default.isPasswordStrong.mockReturnValue(true);
+            auth_service_1.default.hashPassword.mockResolvedValueOnce("newHashedPassword123");
+            yield controllerWithMiddleware.updatePassword(req, res, next);
+            (0, vitest_1.expect)(req.responseData).toEqual({
+                status: "success",
+                message: "Password updated successfully!",
+            });
+            (0, vitest_1.expect)(req.responseStatus).toBe(200);
+            (0, vitest_1.expect)(req.additionalData).toEqual({
+                user: req.user,
+            });
+            (0, vitest_1.expect)(next).toHaveBeenCalled();
+            (0, vitest_1.expect)(res.status).not.toHaveBeenCalled();
+        }));
+    });
+});
+//# sourceMappingURL=auth.controller.test.js.map