@ackplus/nest-auth 1.1.0 → 1.1.2

package/src/lib/admin-console/controllers/admin-users.controller.d.ts

@@ -0,0 +1,146 @@
+import { Repository } from 'typeorm';
+import { AdminCreateUserDto, AdminUpdateUserDto } from '../dto/admin-user.dto';
+import { UserService } from '../../user/services/user.service';
+import { TenantService } from '../../tenant/services/tenant.service';
+import { NestAuthMFASecret } from '../../auth/entities/mfa-secret.entity';
+import { MfaService } from '../../auth/services/mfa.service';
+import { SessionManagerService } from '../../session/services/session-manager.service';
+export declare class AdminUsersController {
+    private readonly users;
+    private readonly tenantService;
+    private readonly mfaService;
+    private readonly sessionManager;
+    private readonly mfaSecretRepository;
+    constructor(users: UserService, tenantService: TenantService, mfaService: MfaService, sessionManager: SessionManagerService, mfaSecretRepository: Repository<NestAuthMFASecret>);
+    private ensureUserExists;
+    private toSessionResponse;
+    private buildStatusFilter;
+    private escapeLikePattern;
+    listUsers(page?: string, limit?: string, search?: string, status?: string): Promise<{
+        data: {
+            id: string;
+            email: string;
+            phone: string;
+            tenantId: string;
+            isActive: boolean;
+            isVerified: boolean;
+            metadata: Record<string, any>;
+            roles: string[];
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerifiedAt: Date;
+            phoneVerifiedAt: Date;
+            isMfaEnabled: boolean;
+        }[];
+        meta: {
+            page: number;
+            limit: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+    createUser(dto: AdminCreateUserDto): Promise<{
+        user: {
+            id: string;
+            email: string;
+            phone: string;
+            tenantId: string;
+            isActive: boolean;
+            isVerified: boolean;
+            metadata: Record<string, any>;
+            roles: string[];
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerifiedAt: Date;
+            phoneVerifiedAt: Date;
+            isMfaEnabled: boolean;
+        };
+    }>;
+    getUser(id: string): Promise<{
+        user: {
+            id: string;
+            email: string;
+            phone: string;
+            tenantId: string;
+            isActive: boolean;
+            isVerified: boolean;
+            metadata: Record<string, any>;
+            roles: string[];
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerifiedAt: Date;
+            phoneVerifiedAt: Date;
+            isMfaEnabled: boolean;
+        };
+        loginMethods: {
+            emailEnabled: boolean;
+            phoneEnabled: boolean;
+            hasPassword: boolean;
+        };
+        mfa: {
+            isEnabled: boolean;
+            allowUserToggle: boolean;
+            availableMethods: import("../../core").MFAMethodEnum[];
+            enabledMethods: import("../../core").MFAMethodEnum[];
+            hasRecoveryCode: boolean;
+            totpDevices: {
+                id: string;
+                deviceName: string;
+                verified: boolean;
+                lastUsedAt: Date;
+                createdAt: Date;
+            }[];
+        };
+        sessions: {
+            id: string;
+            deviceName: string;
+            userAgent: string;
+            ipAddress: string;
+            lastActive: Date;
+            createdAt: Date;
+            expiresAt: Date;
+        }[];
+    }>;
+    updateUser(id: string, dto: AdminUpdateUserDto): Promise<{
+        user: {
+            id: string;
+            email: string;
+            phone: string;
+            tenantId: string;
+            isActive: boolean;
+            isVerified: boolean;
+            metadata: Record<string, any>;
+            roles: string[];
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerifiedAt: Date;
+            phoneVerifiedAt: Date;
+            isMfaEnabled: boolean;
+        };
+    }>;
+    deleteTotpDevice(id: string, deviceId: string): Promise<{
+        message: string;
+    }>;
+    listSessions(id: string): Promise<{
+        data: {
+            id: string;
+            deviceName: string;
+            userAgent: string;
+            ipAddress: string;
+            lastActive: Date;
+            createdAt: Date;
+            expiresAt: Date;
+        }[];
+    }>;
+    revokeSession(id: string, sessionId: string): Promise<{
+        message: string;
+    }>;
+    revokeAllSessions(id: string): Promise<{
+        message: string;
+    }>;
+    deleteUser(id: string): Promise<{
+        message: string;
+    }>;
+    private toSafeUser;
+}
+//# sourceMappingURL=admin-users.controller.d.ts.map

package/src/lib/admin-console/controllers/admin-users.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-users.controller.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nest-auth/src/lib/admin-console/controllers/admin-users.controller.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAG1E,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAGvF,qBAEa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;gBALnB,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,qBAAqB,EAErC,mBAAmB,EAAE,UAAU,CAAC,iBAAiB,CAAC;YAGvD,gBAAgB;IAQ9B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,iBAAiB;IAKnB,SAAS,CACE,IAAI,CAAC,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;IAkE5B,UAAU,CAAS,GAAG,EAAE,kBAAkB;;;;;;;;;;;;;;;;;IAyB1C,OAAO,CAAc,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgD/B,UAAU,CAAc,EAAE,EAAE,MAAM,EAAU,GAAG,EAAE,kBAAkB;;;;;;;;;;;;;;;;;IAyEnE,gBAAgB,CAAc,EAAE,EAAE,MAAM,EAAqB,QAAQ,EAAE,MAAM;;;IAmB7E,YAAY,CAAc,EAAE,EAAE,MAAM;;;;;;;;;;;IAepC,aAAa,CAAc,EAAE,EAAE,MAAM,EAAsB,SAAS,EAAE,MAAM;;;IAiB5E,iBAAiB,CAAc,EAAE,EAAE,MAAM;;;IAOzC,UAAU,CAAc,EAAE,EAAE,MAAM;;;IAKxC,OAAO,CAAC,UAAU;CAoBnB"}

package/src/lib/admin-console/controllers/admin-users.controller.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminUsersController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const common_2 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const admin_session_guard_1 = require("../guards/admin-session.guard");
+const admin_user_dto_1 = require("../dto/admin-user.dto");
+const user_service_1 = require("../../user/services/user.service");
+const tenant_service_1 = require("../../tenant/services/tenant.service");
+const mfa_secret_entity_1 = require("../../auth/entities/mfa-secret.entity");
+const auth_constants_1 = require("../../auth.constants");
+const typeorm_3 = require("typeorm");
+const mfa_service_1 = require("../../auth/services/mfa.service");
+const session_manager_service_1 = require("../../session/services/session-manager.service");
+let AdminUsersController = class AdminUsersController {
+    constructor(users, tenantService, mfaService, sessionManager, mfaSecretRepository) {
+        this.users = users;
+        this.tenantService = tenantService;
+        this.mfaService = mfaService;
+        this.sessionManager = sessionManager;
+        this.mfaSecretRepository = mfaSecretRepository;
+    }
+    async ensureUserExists(id) {
+        const user = await this.users.getUserById(id);
+        if (!user) {
+            throw new common_2.NotFoundException('User not found');
+        }
+        return user;
+    }
+    toSessionResponse(session) {
+        return {
+            id: session.id,
+            deviceName: session.deviceName || 'Unknown device',
+            userAgent: session.userAgent,
+            ipAddress: session.ipAddress,
+            lastActive: session.lastActive,
+            createdAt: session.createdAt,
+            expiresAt: session.expiresAt,
+        };
+    }
+    buildStatusFilter(status) {
+        if (!status)
+            return {};
+        switch (status) {
+            case 'active':
+                return { isActive: true };
+            case 'inactive':
+                return { isActive: false };
+            case 'verified':
+                return { isVerified: true };
+            case 'unverified':
+                return { isVerified: false };
+            default:
+                return {};
+        }
+    }
+    escapeLikePattern(value) {
+        return value.replace(/[%_\\]/g, '\\$&');
+    }
+    async listUsers(page, limit, search, status) {
+        // Validate and sanitize pagination parameters
+        let pageNum = parseInt(page || '1', 10);
+        let limitNum = parseInt(limit || '10', 10);
+        // Ensure page is at least 1
+        if (isNaN(pageNum) || pageNum < 1) {
+            pageNum = 1;
+        }
+        // Ensure limit is positive and capped at 100
+        if (isNaN(limitNum) || limitNum <= 0) {
+            limitNum = 10;
+        }
+        if (limitNum > 100) {
+            limitNum = 100;
+        }
+        const skip = (pageNum - 1) * limitNum;
+        // Build where clause with proper TypeORM typing
+        let where = {};
+        // Apply search filter with proper OR conditions using array syntax
+        if (search && search.trim()) {
+            const escapedSearch = this.escapeLikePattern(search.trim());
+            const searchPattern = `%${escapedSearch}%`;
+            // Base status filter if present
+            const baseFilter = {
+                ...this.buildStatusFilter(status),
+            };
+            // Create OR conditions for search
+            where = [
+                { ...baseFilter, email: (0, typeorm_3.Like)(searchPattern) },
+                { ...baseFilter, phone: (0, typeorm_3.Like)(searchPattern) },
+                { ...baseFilter, tenantId: (0, typeorm_3.Like)(searchPattern) },
+            ];
+        }
+        else {
+            // Apply status filter without search
+            Object.assign(where, this.buildStatusFilter(status));
+        }
+        // Get users and total count in a single query
+        const [users, total] = await this.users.getUsersAndCount({
+            where,
+            relations: ['roles'],
+            order: { createdAt: 'DESC' },
+            skip,
+            take: limitNum,
+        });
+        return {
+            data: users.map((user) => this.toSafeUser(user)),
+            meta: {
+                page: pageNum,
+                limit: limitNum,
+                total,
+                totalPages: Math.ceil(total / limitNum),
+            },
+        };
+    }
+    async createUser(dto) {
+        const tenantId = await this.tenantService.resolveTenantId(dto.tenantId);
+        const user = await this.users.createUser({
+            email: dto.email,
+            phone: dto.phone,
+            tenantId,
+            metadata: dto.metadata ?? {},
+            isActive: dto.isActive ?? true,
+            isVerified: dto.isVerified ?? false,
+        });
+        if (dto.password) {
+            await user.setPassword(dto.password);
+            await user.save();
+        }
+        if (dto.roles?.length) {
+            await user.assignRoles(dto.roles, auth_constants_1.DEFAULT_GUARD_NAME);
+            await user.save();
+        }
+        return { user: this.toSafeUser(user) };
+    }
+    async getUser(id) {
+        const user = await this.users.getUserById(id, {
+            relations: ['roles', 'mfaSecrets', 'identities']
+        });
+        if (!user) {
+            throw new common_2.NotFoundException('User not found');
+        }
+        const availableMethods = this.mfaService.getAvailableMethods();
+        const [enabledMethods, sessions] = await Promise.all([
+            this.mfaService.getEnabledMethods(user.id),
+            this.sessionManager.getUserSessions(user.id),
+        ]);
+        const sortedSessions = sessions
+            .sort((a, b) => {
+            const aTime = a.lastActive?.getTime() ?? a.updatedAt?.getTime() ?? 0;
+            const bTime = b.lastActive?.getTime() ?? b.updatedAt?.getTime() ?? 0;
+            return bTime - aTime;
+        })
+            .map((session) => this.toSessionResponse(session));
+        return {
+            user: this.toSafeUser(user),
+            loginMethods: {
+                emailEnabled: !!user.email && !!user.emailVerifiedAt,
+                phoneEnabled: !!user.phone && !!user.phoneVerifiedAt,
+                hasPassword: !!user.passwordHash,
+            },
+            mfa: {
+                isEnabled: user.isMfaEnabled,
+                allowUserToggle: this.mfaService.mfaConfig?.allowUserToggle ?? false,
+                availableMethods,
+                enabledMethods,
+                hasRecoveryCode: !!user.mfaRecoveryCode,
+                totpDevices: user.mfaSecrets?.map((device) => ({
+                    id: device.id,
+                    deviceName: device.deviceName || 'Authenticator',
+                    verified: device.verified,
+                    lastUsedAt: device.lastUsedAt,
+                    createdAt: device.createdAt,
+                })) || [],
+            },
+            sessions: sortedSessions,
+        };
+    }
+    async updateUser(id, dto) {
+        let user = await this.users.getUserById(id, { relations: ['roles', 'identities'] });
+        if (!user) {
+            throw new common_2.NotFoundException('User not found');
+        }
+        // Apply basic field updates if provided
+        if (dto.isActive !== undefined || dto.isVerified !== undefined || dto.metadata !== undefined ||
+            dto.isMfaEnabled !== undefined) {
+            const updates = {};
+            if (dto.isActive !== undefined)
+                updates.isActive = dto.isActive;
+            if (dto.isVerified !== undefined)
+                updates.isVerified = dto.isVerified;
+            if (dto.metadata !== undefined)
+                updates.metadata = dto.metadata;
+            if (dto.isMfaEnabled !== undefined)
+                updates.isMfaEnabled = dto.isMfaEnabled;
+            user = await this.users.updateUser(id, updates);
+        }
+        // Enable/disable email login
+        if (dto.emailLoginEnabled !== undefined) {
+            if (dto.emailLoginEnabled) {
+                if (!user.email) {
+                    throw new common_2.NotFoundException('User has no email address');
+                }
+                user.emailVerifiedAt = user.emailVerifiedAt || new Date();
+                // Ensure identity exists
+                await user.findOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, user.email);
+            }
+            else {
+                user.emailVerifiedAt = null;
+                // Remove email identity if exists
+                const emailIdentity = user.identities?.find(i => i.provider === auth_constants_1.EMAIL_AUTH_PROVIDER);
+                if (emailIdentity) {
+                    await emailIdentity.remove();
+                }
+            }
+        }
+        // Enable/disable phone login
+        if (dto.phoneLoginEnabled !== undefined) {
+            if (dto.phoneLoginEnabled) {
+                if (!user.phone) {
+                    throw new common_2.NotFoundException('User has no phone number');
+                }
+                user.phoneVerifiedAt = user.phoneVerifiedAt || new Date();
+                // Ensure identity exists
+                await user.findOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, user.phone);
+            }
+            else {
+                user.phoneVerifiedAt = null;
+                // Remove phone identity if exists
+                const phoneIdentity = user.identities?.find(i => i.provider === auth_constants_1.PHONE_AUTH_PROVIDER);
+                if (phoneIdentity) {
+                    await phoneIdentity.remove();
+                }
+            }
+        }
+        // Apply password change in-memory
+        if (dto.password) {
+            await user.setPassword(dto.password);
+        }
+        // Apply role changes in-memory
+        if (dto.roles) {
+            await user.assignRoles(dto.roles, auth_constants_1.DEFAULT_GUARD_NAME);
+        }
+        // Save all changes
+        await user.save();
+        return { user: this.toSafeUser(user) };
+    }
+    async deleteTotpDevice(id, deviceId) {
+        const user = await this.users.getUserById(id);
+        if (!user) {
+            throw new common_2.NotFoundException('User not found');
+        }
+        const device = await this.mfaSecretRepository.findOne({
+            where: { id: deviceId, userId: user.id },
+        });
+        if (!device) {
+            throw new common_2.NotFoundException('TOTP device not found');
+        }
+        await this.mfaSecretRepository.remove(device);
+        return { message: 'TOTP device deleted successfully' };
+    }
+    async listSessions(id) {
+        const user = await this.ensureUserExists(id);
+        const sessions = await this.sessionManager.getUserSessions(user.id);
+        return {
+            data: sessions
+                .sort((a, b) => {
+                const aTime = a.lastActive?.getTime() ?? a.updatedAt?.getTime() ?? 0;
+                const bTime = b.lastActive?.getTime() ?? b.updatedAt?.getTime() ?? 0;
+                return bTime - aTime;
+            })
+                .map((session) => this.toSessionResponse(session)),
+        };
+    }
+    async revokeSession(id, sessionId) {
+        const user = await this.ensureUserExists(id);
+        try {
+            const session = await this.sessionManager.getSession(sessionId, false);
+            if (session.userId !== user.id) {
+                throw new common_2.NotFoundException('Session not found for this user');
+            }
+        }
+        catch {
+            throw new common_2.NotFoundException('Session not found for this user');
+        }
+        await this.sessionManager.revokeSession(sessionId);
+        return { message: 'Session revoked successfully' };
+    }
+    async revokeAllSessions(id) {
+        const user = await this.ensureUserExists(id);
+        await this.sessionManager.revokeAllUserSessions(user.id);
+        return { message: 'All sessions revoked successfully' };
+    }
+    async deleteUser(id) {
+        await this.users.deleteUser(id);
+        return { message: 'User removed' };
+    }
+    toSafeUser(user) {
+        if (!user) {
+            return null;
+        }
+        return {
+            id: user.id,
+            email: user.email,
+            phone: user.phone,
+            tenantId: user.tenantId,
+            isActive: user.isActive,
+            isVerified: user.isVerified,
+            metadata: user.metadata ?? {},
+            roles: user.roles?.map((role) => role.name) ?? [],
+            createdAt: user.createdAt,
+            updatedAt: user.updatedAt,
+            emailVerifiedAt: user.emailVerifiedAt,
+            phoneVerifiedAt: user.phoneVerifiedAt,
+            isMfaEnabled: user.isMfaEnabled,
+        };
+    }
+};
+exports.AdminUsersController = AdminUsersController;
+tslib_1.__decorate([
+    (0, common_1.Get)(),
+    tslib_1.__param(0, (0, common_1.Query)('page')),
+    tslib_1.__param(1, (0, common_1.Query)('limit')),
+    tslib_1.__param(2, (0, common_1.Query)('search')),
+    tslib_1.__param(3, (0, common_1.Query)('status')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String, String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "listUsers", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(),
+    tslib_1.__param(0, (0, common_1.Body)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [admin_user_dto_1.AdminCreateUserDto]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "createUser", null);
+tslib_1.__decorate([
+    (0, common_1.Get)(':id'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "getUser", null);
+tslib_1.__decorate([
+    (0, common_1.Patch)(':id'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, admin_user_dto_1.AdminUpdateUserDto]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "updateUser", null);
+tslib_1.__decorate([
+    (0, common_1.Delete)(':id/totp-devices/:deviceId'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__param(1, (0, common_1.Param)('deviceId')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "deleteTotpDevice", null);
+tslib_1.__decorate([
+    (0, common_1.Get)(':id/sessions'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "listSessions", null);
+tslib_1.__decorate([
+    (0, common_1.Delete)(':id/sessions/:sessionId'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__param(1, (0, common_1.Param)('sessionId')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "revokeSession", null);
+tslib_1.__decorate([
+    (0, common_1.Delete)(':id/sessions'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "revokeAllSessions", null);
+tslib_1.__decorate([
+    (0, common_1.Delete)(':id'),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], AdminUsersController.prototype, "deleteUser", null);
+exports.AdminUsersController = AdminUsersController = tslib_1.__decorate([
+    (0, common_1.Controller)('auth/admin/api/users'),
+    (0, common_1.UseGuards)(admin_session_guard_1.AdminSessionGuard),
+    tslib_1.__param(4, (0, typeorm_1.InjectRepository)(mfa_secret_entity_1.NestAuthMFASecret)),
+    tslib_1.__metadata("design:paramtypes", [user_service_1.UserService,
+        tenant_service_1.TenantService,
+        mfa_service_1.MfaService,
+        session_manager_service_1.SessionManagerService,
+        typeorm_2.Repository])
+], AdminUsersController);

package/src/lib/admin-console/decorators/current-admin.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const CurrentAdmin: (...dataOrPipes: unknown[]) => ParameterDecorator;
+//# sourceMappingURL=current-admin.decorator.d.ts.map

package/src/lib/admin-console/decorators/current-admin.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-admin.decorator.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nest-auth/src/lib/admin-console/decorators/current-admin.decorator.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,mDAKxB,CAAC"}

package/src/lib/admin-console/decorators/current-admin.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentAdmin = void 0;
+const common_1 = require("@nestjs/common");
+exports.CurrentAdmin = (0, common_1.createParamDecorator)((data, context) => {
+    const request = context.switchToHttp().getRequest();
+    return request.adminUser;
+});

package/src/lib/admin-console/dto/admin-permission.dto.d.ts

@@ -0,0 +1,16 @@
+export declare class AdminCreatePermissionDto {
+    name: string;
+    guard?: string;
+    description?: string;
+    category?: string;
+    metadata?: Record<string, any>;
+}
+export declare class AdminUpdatePermissionDto {
+    name?: string;
+    guard?: string;
+    updateInRoles?: boolean;
+    description?: string;
+    category?: string;
+    metadata?: Record<string, any>;
+}
+//# sourceMappingURL=admin-permission.dto.d.ts.map

package/src/lib/admin-console/dto/admin-permission.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-permission.dto.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nest-auth/src/lib/admin-console/dto/admin-permission.dto.ts"],"names":[],"mappings":"AAGA,qBAAa,wBAAwB;IAWjC,IAAI,EAAE,MAAM,CAAC;IASb,KAAK,CAAC,EAAE,MAAM,CAAC;IASf,WAAW,CAAC,EAAE,MAAM,CAAC;IASrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IASlB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED,qBAAa,wBAAwB;IAUjC,IAAI,CAAC,EAAE,MAAM,CAAC;IASd,KAAK,CAAC,EAAE,MAAM,CAAC;IAQf,aAAa,CAAC,EAAE,OAAO,CAAC;IAQxB,WAAW,CAAC,EAAE,MAAM,CAAC;IAQrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAQlB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC"}