@flusys/nestjs-auth 7.0.2 → 8.0.0-beta.1

package/cjs/controllers/company.controller.spec.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
-const _companycontroller = require("./company.controller");
-function buildCompany(overrides = {}) {
-    return {
-        id: 'company-1',
-        name: 'Acme Corporation',
-        slug: 'acme-corp',
-        logoId: null,
-        address: null,
-        phone: null,
-        email: null,
-        website: null,
-        serial: null,
-        isActive: true,
-        readOnly: false,
-        settings: null,
-        additionalFields: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides
-    };
-}
-describe('CompanyController', ()=>{
-    let controller;
-    let mockCompanyService;
-    beforeEach(()=>{
-        mockCompanyService = {
-            insert: jest.fn(),
-            insertMany: jest.fn(),
-            findById: jest.fn(),
-            findByIds: jest.fn(),
-            update: jest.fn(),
-            updateMany: jest.fn(),
-            bulkUpsert: jest.fn(),
-            getAll: jest.fn(),
-            delete: jest.fn()
-        };
-        controller = new _companycontroller.CompanyController(mockCompanyService);
-    });
-    it('wires the injected service onto the generated controller base', ()=>{
-        expect(controller.companyService).toBe(mockCompanyService);
-        expect(controller.service).toBe(mockCompanyService);
-    });
-    describe('insert', ()=>{
-        it('creates a company and returns the mapped response', async ()=>{
-            const user = (0, _loggedusermock.buildMockUser)();
-            const company = buildCompany();
-            mockCompanyService.insert.mockResolvedValue(company);
-            const result = await controller.insert({
-                name: 'Acme Corporation',
-                slug: 'acme-corp'
-            }, user);
-            expect(mockCompanyService.insert).toHaveBeenCalledWith({
-                name: 'Acme Corporation',
-                slug: 'acme-corp'
-            }, user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'company-1',
-                slug: 'acme-corp'
-            }));
-        });
-    });
-    describe('getById', ()=>{
-        it('retrieves a company by id', async ()=>{
-            mockCompanyService.findById.mockResolvedValue(buildCompany());
-            const result = await controller.getById('company-1', {}, null);
-            expect(mockCompanyService.findById).toHaveBeenCalledWith('company-1', null, undefined);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'company-1'
-            }));
-        });
-    });
-    describe('getAll', ()=>{
-        it('paginates companies and maps the response list', async ()=>{
-            mockCompanyService.getAll.mockResolvedValue({
-                data: [
-                    buildCompany()
-                ],
-                total: 1
-            });
-            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), 'acme');
-            expect(mockCompanyService.getAll).toHaveBeenCalledWith('acme', {}, (0, _loggedusermock.buildMockUser)());
-            expect(result.data).toHaveLength(1);
-            expect(result.meta.total).toBe(1);
-        });
-    });
-    describe('update', ()=>{
-        it('updates a company and returns the mapped response', async ()=>{
-            const company = buildCompany({
-                name: 'Updated Co'
-            });
-            mockCompanyService.update.mockResolvedValue(company);
-            const result = await controller.update({
-                id: 'company-1',
-                name: 'Updated Co'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(mockCompanyService.update).toHaveBeenCalledWith({
-                id: 'company-1',
-                name: 'Updated Co'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(result.data).toEqual(expect.objectContaining({
-                name: 'Updated Co'
-            }));
-        });
-    });
-    describe('delete', ()=>{
-        it('delegates soft-delete to the service', async ()=>{
-            mockCompanyService.delete.mockResolvedValue({
-                count: 1
-            });
-            const result = await controller.delete({
-                id: [
-                    'company-1'
-                ],
-                type: 'delete'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(mockCompanyService.delete).toHaveBeenCalledWith({
-                id: [
-                    'company-1'
-                ],
-                type: 'delete'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(result.success).toBe(true);
-        });
-    });
-});

package/cjs/controllers/email-verification.controller.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EmailVerificationController", {
-    enumerable: true,
-    get: function() {
-        return EmailVerificationController;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _dtos = require("@flusys/nestjs-shared/dtos");
-const _common = require("@nestjs/common");
-const _swagger = require("@nestjs/swagger");
-const _throttler = require("@nestjs/throttler");
-const _express = require("express");
-const _config = require("../config");
-const _authenticationdto = require("../dtos/authentication.dto");
-const _settokeninterceptor = require("../interceptors/set-token.interceptor");
-const _authconfigservice = require("../services/auth-config.service");
-const _authdatasourceprovider = require("../services/auth-datasource.provider");
-const _authemailservice = require("../services/auth-email.service");
-const _authenticationservice = require("../services/authentication.service");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let EmailVerificationController = class EmailVerificationController {
-    ensureEmailVerificationEnabled() {
-        if (!this.dataSourceProvider.isEmailVerificationEnabled()) {
-            throw new _common.BadRequestException({
-                message: 'Email verification is not enabled for this tenant',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_NOT_ENABLED
-            });
-        }
-    }
-    async forgotPassword(req, dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.forgotPassword(dto.email, (0, _nestjsshared.buildFrontendUrl)(req, '/auth/reset-password'));
-    }
-    async resetPassword(dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.resetPassword(dto.token, dto.newPassword);
-    }
-    async resendVerification(req, dto) {
-        this.ensureEmailVerificationEnabled();
-        return this.authEmailService.resendVerificationEmail(dto.email, (0, _nestjsshared.buildFrontendUrl)(req, '/auth/verify-email'));
-    }
-    async verifyEmail(dto) {
-        this.ensureEmailVerificationEnabled();
-        const result = await this.authEmailService.verifyEmail(dto.token);
-        if (result.type === 'pending') {
-            const data = await this.authService.createUserFromPendingRegistration(result.pending);
-            return {
-                success: true,
-                message: 'Registration completed successfully',
-                messageKey: _config.AUTH_MESSAGES.REGISTER_SUCCESS,
-                data
-            };
-        }
-        return {
-            success: true,
-            message: result.message,
-            messageKey: result.messageKey
-        };
-    }
-    constructor(authService, authEmailService, authConfig, dataSourceProvider){
-        _define_property(this, "authService", void 0);
-        _define_property(this, "authEmailService", void 0);
-        _define_property(this, "authConfig", void 0);
-        _define_property(this, "dataSourceProvider", void 0);
-        this.authService = authService;
-        this.authEmailService = authEmailService;
-        this.authConfig = authConfig;
-        this.dataSourceProvider = dataSourceProvider;
-    }
-};
-_ts_decorate([
-    (0, _common.Post)('forgot-password'),
-    (0, _common.HttpCode)(_common.HttpStatus.OK),
-    (0, _throttler.Throttle)({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    (0, _swagger.ApiOperation)({
-        summary: 'Request password reset email'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _authenticationdto.ForgotPasswordDto
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        type: _dtos.MessageResponseDto
-    }),
-    _ts_param(0, (0, _common.Req)()),
-    _ts_param(1, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _express.Request === "undefined" ? Object : _express.Request,
-        typeof _authenticationdto.ForgotPasswordDto === "undefined" ? Object : _authenticationdto.ForgotPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "forgotPassword", null);
-_ts_decorate([
-    (0, _common.Post)('reset-password'),
-    (0, _common.HttpCode)(_common.HttpStatus.OK),
-    (0, _throttler.Throttle)({
-        default: {
-            limit: 5,
-            ttl: 900000
-        }
-    }),
-    (0, _swagger.ApiOperation)({
-        summary: 'Reset password using token'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _authenticationdto.ResetPasswordDto
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        type: _dtos.MessageResponseDto
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authenticationdto.ResetPasswordDto === "undefined" ? Object : _authenticationdto.ResetPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "resetPassword", null);
-_ts_decorate([
-    (0, _common.Post)('resend-verification'),
-    (0, _common.HttpCode)(_common.HttpStatus.OK),
-    (0, _throttler.Throttle)({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    (0, _swagger.ApiOperation)({
-        summary: 'Resend email verification link'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _authenticationdto.ResendVerificationDto
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        type: _dtos.MessageResponseDto
-    }),
-    _ts_param(0, (0, _common.Req)()),
-    _ts_param(1, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _express.Request === "undefined" ? Object : _express.Request,
-        typeof _authenticationdto.ResendVerificationDto === "undefined" ? Object : _authenticationdto.ResendVerificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "resendVerification", null);
-_ts_decorate([
-    (0, _common.Post)('verify-email'),
-    (0, _common.HttpCode)(_common.HttpStatus.OK),
-    (0, _throttler.Throttle)({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    (0, _common.UseInterceptors)(_settokeninterceptor.SetToken),
-    (0, _swagger.ApiOperation)({
-        summary: 'Verify email using token'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _authenticationdto.VerifyEmailDto
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        description: 'Email verified or registration completed'
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authenticationdto.VerifyEmailDto === "undefined" ? Object : _authenticationdto.VerifyEmailDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailVerificationController.prototype, "verifyEmail", null);
-EmailVerificationController = _ts_decorate([
-    (0, _swagger.ApiTags)('Authentication'),
-    (0, _common.Controller)('auth'),
-    _ts_param(0, (0, _common.Inject)(_authenticationservice.AuthenticationService)),
-    _ts_param(1, (0, _common.Inject)(_authemailservice.AuthEmailService)),
-    _ts_param(2, (0, _common.Inject)(_authconfigservice.AuthConfigService)),
-    _ts_param(3, (0, _common.Inject)(_authdatasourceprovider.AuthDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authenticationservice.AuthenticationService === "undefined" ? Object : _authenticationservice.AuthenticationService,
-        typeof _authemailservice.AuthEmailService === "undefined" ? Object : _authemailservice.AuthEmailService,
-        typeof _authconfigservice.AuthConfigService === "undefined" ? Object : _authconfigservice.AuthConfigService,
-        typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider
-    ])
-], EmailVerificationController);

package/cjs/controllers/email-verification.controller.spec.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _emailverificationcontroller = require("./email-verification.controller");
-function buildRequest() {
-    return {
-        headers: {},
-        get: jest.fn((h)=>h === 'host' ? 'app.example.com' : undefined),
-        protocol: 'https'
-    };
-}
-describe('EmailVerificationController', ()=>{
-    let controller;
-    let mockAuthService;
-    let mockAuthEmailService;
-    let mockAuthConfig;
-    let mockDataSourceProvider;
-    beforeEach(()=>{
-        mockAuthService = {
-            createUserFromPendingRegistration: jest.fn()
-        };
-        mockAuthEmailService = {
-            forgotPassword: jest.fn(),
-            resetPassword: jest.fn(),
-            resendVerificationEmail: jest.fn(),
-            verifyEmail: jest.fn()
-        };
-        mockAuthConfig = {};
-        mockDataSourceProvider = {
-            isEmailVerificationEnabled: jest.fn().mockReturnValue(true)
-        };
-        controller = new _emailverificationcontroller.EmailVerificationController(mockAuthService, mockAuthEmailService, mockAuthConfig, mockDataSourceProvider);
-    });
-    describe('when email verification is disabled for the tenant', ()=>{
-        beforeEach(()=>{
-            mockDataSourceProvider.isEmailVerificationEnabled.mockReturnValue(false);
-        });
-        it('rejects forgotPassword', async ()=>{
-            await expect(controller.forgotPassword(buildRequest(), {
-                email: 'a@example.com'
-            })).rejects.toThrow(_common.BadRequestException);
-        });
-        it('rejects resetPassword', async ()=>{
-            await expect(controller.resetPassword({
-                token: 't',
-                newPassword: 'New1!aaaa'
-            })).rejects.toThrow(_common.BadRequestException);
-        });
-        it('rejects resendVerification', async ()=>{
-            await expect(controller.resendVerification(buildRequest(), {
-                email: 'a@example.com'
-            })).rejects.toThrow(_common.BadRequestException);
-        });
-        it('rejects verifyEmail', async ()=>{
-            await expect(controller.verifyEmail({
-                token: 't'
-            })).rejects.toThrow(_common.BadRequestException);
-        });
-    });
-    describe('forgotPassword', ()=>{
-        it('delegates to authEmailService with a built frontend reset URL', async ()=>{
-            mockAuthEmailService.forgotPassword.mockResolvedValue({
-                success: true,
-                message: 'sent',
-                messageKey: 'auth.password.reset.email.sent'
-            });
-            const result = await controller.forgotPassword(buildRequest(), {
-                email: 'a@example.com'
-            });
-            expect(mockAuthEmailService.forgotPassword).toHaveBeenCalledWith('a@example.com', expect.any(String));
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('resetPassword', ()=>{
-        it('delegates to authEmailService.resetPassword', async ()=>{
-            mockAuthEmailService.resetPassword.mockResolvedValue({
-                success: true,
-                message: 'done',
-                messageKey: 'auth.password.reset.success'
-            });
-            const result = await controller.resetPassword({
-                token: 'tok',
-                newPassword: 'New1!aaaa'
-            });
-            expect(mockAuthEmailService.resetPassword).toHaveBeenCalledWith('tok', 'New1!aaaa');
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('resendVerification', ()=>{
-        it('delegates to authEmailService.resendVerificationEmail', async ()=>{
-            mockAuthEmailService.resendVerificationEmail.mockResolvedValue({
-                success: true,
-                message: 'sent',
-                messageKey: 'email.verification.resend.success'
-            });
-            await controller.resendVerification(buildRequest(), {
-                email: 'a@example.com'
-            });
-            expect(mockAuthEmailService.resendVerificationEmail).toHaveBeenCalledWith('a@example.com', expect.any(String));
-        });
-    });
-    describe('verifyEmail', ()=>{
-        it('completes registration when the token resolves a pending registration', async ()=>{
-            mockAuthEmailService.verifyEmail.mockResolvedValue({
-                type: 'pending',
-                pending: {
-                    id: 'pending-1'
-                }
-            });
-            mockAuthService.createUserFromPendingRegistration.mockResolvedValue({
-                accessToken: 'a'
-            });
-            const result = await controller.verifyEmail({
-                token: 'tok'
-            });
-            expect(mockAuthService.createUserFromPendingRegistration).toHaveBeenCalledWith({
-                id: 'pending-1'
-            });
-            expect(result.data).toEqual({
-                accessToken: 'a'
-            });
-        });
-        it('returns the verification message when the token verifies an existing user token', async ()=>{
-            mockAuthEmailService.verifyEmail.mockResolvedValue({
-                type: 'verified',
-                message: 'Email has been verified successfully.',
-                messageKey: 'email.verification.success'
-            });
-            const result = await controller.verifyEmail({
-                token: 'tok'
-            });
-            expect(result).toEqual({
-                success: true,
-                message: 'Email has been verified successfully.',
-                messageKey: 'email.verification.success'
-            });
-            expect(mockAuthService.createUserFromPendingRegistration).not.toHaveBeenCalled();
-        });
-    });
-});

package/cjs/controllers/index.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./authentication.controller"), exports);
-_export_star(require("./company-selection.controller"), exports);
-_export_star(require("./email-verification.controller"), exports);
-_export_star(require("./user.controller"), exports);
-_export_star(require("./company.controller"), exports);
-_export_star(require("./branch.controller"), exports);
-_export_star(require("./user-permission.controller"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}