@ciscode/authentication-kit 1.1.6 → 1.2.0

package/dist/models/user.model.js

@@ -1,45 +1,86 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserSchema = void 0;
-const mongoose_1 = __importDefault(require("mongoose"));
-const mongoose_paginate_v2_1 = __importDefault(require("mongoose-paginate-v2"));
-const UserSchema = new mongoose_1.default.Schema({
-    email: {
-        type: String,
-        required: function () {
-            return !this.microsoftId && !this.googleId && !this.facebookId;
-        },
+exports.UserSchema = exports.User = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+let FullName = class FullName {
+};
+__decorate([
+    (0, mongoose_1.Prop)({ required: true, trim: true }),
+    __metadata("design:type", String)
+], FullName.prototype, "fname", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: true, trim: true }),
+    __metadata("design:type", String)
+], FullName.prototype, "lname", void 0);
+FullName = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], FullName);
+const FullNameSchema = mongoose_1.SchemaFactory.createForClass(FullName);
+let User = class User {
+};
+exports.User = User;
+__decorate([
+    (0, mongoose_1.Prop)({ type: FullNameSchema, required: true }),
+    __metadata("design:type", FullName)
+], User.prototype, "fullname", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: true, unique: true, trim: true, minlength: 3, maxlength: 30 }),
+    __metadata("design:type", String)
+], User.prototype, "username", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        unique: true,
+        lowercase: true,
+        trim: true,
+        match: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+    }),
+    __metadata("design:type", String)
+], User.prototype, "email", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: 'default.jpg' }),
+    __metadata("design:type", String)
+], User.prototype, "avatar", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({
         unique: true,
-        sparse: true
-    },
-    password: {
-        type: String,
-        required: function () {
-            return !this.microsoftId && !this.googleId && !this.facebookId;
-        }
-    },
-    name: { type: String },
-    jobTitle: { type: String },
-    company: { type: String },
-    microsoftId: { type: String, index: true },
-    googleId: { type: String, index: true },
-    facebookId: { type: String, index: true },
-    roles: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: 'Role' }],
-    resetPasswordToken: { type: String },
-    resetPasswordExpires: { type: Date },
-    status: {
-        type: String,
-        enum: ['pending', 'active', 'suspended', 'deactivated'],
-        default: 'pending'
-    },
-    refreshToken: { type: String },
-    failedLoginAttempts: { type: Number, default: 0 },
-    lockUntil: { type: Date }
-}, { timestamps: true });
-exports.UserSchema = UserSchema;
-UserSchema.plugin(mongoose_paginate_v2_1.default);
-const User = mongoose_1.default.models.User || mongoose_1.default.model('User', UserSchema);
-exports.default = User;
+        trim: true,
+        sparse: true,
+        match: /^[0-9]{10,14}$/,
+    }),
+    __metadata("design:type", String)
+], User.prototype, "phoneNumber", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ minlength: 8, select: false }),
+    __metadata("design:type", String)
+], User.prototype, "password", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: Date.now }),
+    __metadata("design:type", Date)
+], User.prototype, "passwordChangedAt", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: [{ type: mongoose_2.Types.ObjectId, ref: 'Role' }], required: true }),
+    __metadata("design:type", Array)
+], User.prototype, "roles", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: false }),
+    __metadata("design:type", Boolean)
+], User.prototype, "isVerified", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: false }),
+    __metadata("design:type", Boolean)
+], User.prototype, "isBanned", void 0);
+exports.User = User = __decorate([
+    (0, mongoose_1.Schema)({ timestamps: true })
+], User);
+exports.UserSchema = mongoose_1.SchemaFactory.createForClass(User);

package/dist/repositories/permission.repository.d.ts

@@ -0,0 +1,34 @@
+import type { Model, Types } from 'mongoose';
+import { Permission, PermissionDocument } from '../models/permission.model';
+export declare class PermissionRepository {
+    private readonly permModel;
+    constructor(permModel: Model<PermissionDocument>);
+    create(data: Partial<Permission>): Promise<import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }>;
+    findById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, PermissionDocument, "findOne">;
+    findByName(name: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, PermissionDocument, "findOne">;
+    list(): import("mongoose").Query<(import("mongoose").FlattenMaps<PermissionDocument> & {
+        _id: Types.ObjectId;
+    })[], import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, PermissionDocument, "find">;
+    updateById(id: string | Types.ObjectId, data: Partial<Permission>): import("mongoose").Query<import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, PermissionDocument, "findOneAndUpdate">;
+    deleteById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, PermissionDocument> & Permission & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, PermissionDocument, "findOneAndDelete">;
+}

package/dist/repositories/permission.repository.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const permission_model_1 = require("../models/permission.model");
+let PermissionRepository = class PermissionRepository {
+    constructor(permModel) {
+        this.permModel = permModel;
+    }
+    create(data) {
+        return this.permModel.create(data);
+    }
+    findById(id) {
+        return this.permModel.findById(id);
+    }
+    findByName(name) {
+        return this.permModel.findOne({ name });
+    }
+    list() {
+        return this.permModel.find().lean();
+    }
+    updateById(id, data) {
+        return this.permModel.findByIdAndUpdate(id, data, { new: true });
+    }
+    deleteById(id) {
+        return this.permModel.findByIdAndDelete(id);
+    }
+};
+exports.PermissionRepository = PermissionRepository;
+exports.PermissionRepository = PermissionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(permission_model_1.Permission.name)),
+    __metadata("design:paramtypes", [Function])
+], PermissionRepository);

package/dist/repositories/role.repository.d.ts

@@ -0,0 +1,39 @@
+import type { Model, Types } from 'mongoose';
+import { Role, RoleDocument } from '../models/role.model';
+export declare class RoleRepository {
+    private readonly roleModel;
+    constructor(roleModel: Model<RoleDocument>);
+    create(data: Partial<Role>): Promise<import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }>;
+    findById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "findOne">;
+    findByName(name: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "findOne">;
+    list(): import("mongoose").Query<(import("mongoose").FlattenMaps<RoleDocument> & {
+        _id: Types.ObjectId;
+    })[], import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "find">;
+    updateById(id: string | Types.ObjectId, data: Partial<Role>): import("mongoose").Query<import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "findOneAndUpdate">;
+    deleteById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "findOneAndDelete">;
+    findByIds(ids: string[]): import("mongoose").Query<(import("mongoose").FlattenMaps<RoleDocument> & {
+        _id: Types.ObjectId;
+    })[], import("mongoose").Document<unknown, {}, RoleDocument> & Role & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, RoleDocument, "find">;
+}

package/dist/repositories/role.repository.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const role_model_1 = require("../models/role.model");
+let RoleRepository = class RoleRepository {
+    constructor(roleModel) {
+        this.roleModel = roleModel;
+    }
+    create(data) {
+        return this.roleModel.create(data);
+    }
+    findById(id) {
+        return this.roleModel.findById(id);
+    }
+    findByName(name) {
+        return this.roleModel.findOne({ name });
+    }
+    list() {
+        return this.roleModel.find().populate('permissions').lean();
+    }
+    updateById(id, data) {
+        return this.roleModel.findByIdAndUpdate(id, data, { new: true });
+    }
+    deleteById(id) {
+        return this.roleModel.findByIdAndDelete(id);
+    }
+    findByIds(ids) {
+        return this.roleModel.find({ _id: { $in: ids } }).lean();
+    }
+};
+exports.RoleRepository = RoleRepository;
+exports.RoleRepository = RoleRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(role_model_1.Role.name)),
+    __metadata("design:paramtypes", [Function])
+], RoleRepository);

package/dist/repositories/user.repository.d.ts

@@ -0,0 +1,57 @@
+import type { Model, Types } from 'mongoose';
+import { User, UserDocument } from '../models/user.model';
+export declare class UserRepository {
+    private readonly userModel;
+    constructor(userModel: Model<UserDocument>);
+    create(data: Partial<User>): Promise<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }>;
+    findById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    findByEmail(email: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    findByEmailWithPassword(email: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    findByUsername(username: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    findByPhone(phoneNumber: string): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    updateById(id: string | Types.ObjectId, data: Partial<User>): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOneAndUpdate">;
+    deleteById(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOneAndDelete">;
+    findByIdWithRolesAndPermissions(id: string | Types.ObjectId): import("mongoose").Query<import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "findOne">;
+    list(filter: {
+        email?: string;
+        username?: string;
+    }): import("mongoose").Query<(import("mongoose").FlattenMaps<UserDocument> & {
+        _id: Types.ObjectId;
+    })[], import("mongoose").Document<unknown, {}, UserDocument> & User & import("mongoose").Document<any, any, any> & {
+        _id: Types.ObjectId;
+    }, {}, UserDocument, "find">;
+}

package/dist/repositories/user.repository.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const user_model_1 = require("../models/user.model");
+let UserRepository = class UserRepository {
+    constructor(userModel) {
+        this.userModel = userModel;
+    }
+    create(data) {
+        return this.userModel.create(data);
+    }
+    findById(id) {
+        return this.userModel.findById(id);
+    }
+    findByEmail(email) {
+        return this.userModel.findOne({ email });
+    }
+    findByEmailWithPassword(email) {
+        return this.userModel.findOne({ email }).select('+password');
+    }
+    findByUsername(username) {
+        return this.userModel.findOne({ username });
+    }
+    findByPhone(phoneNumber) {
+        return this.userModel.findOne({ phoneNumber });
+    }
+    updateById(id, data) {
+        return this.userModel.findByIdAndUpdate(id, data, { new: true });
+    }
+    deleteById(id) {
+        return this.userModel.findByIdAndDelete(id);
+    }
+    findByIdWithRolesAndPermissions(id) {
+        return this.userModel.findById(id).populate({
+            path: 'roles',
+            populate: { path: 'permissions', select: 'name' },
+            select: 'name permissions'
+        });
+    }
+    list(filter) {
+        const query = {};
+        if (filter.email)
+            query.email = filter.email;
+        if (filter.username)
+            query.username = filter.username;
+        return this.userModel
+            .find(query)
+            .populate({ path: 'roles', select: 'name' })
+            .lean();
+    }
+};
+exports.UserRepository = UserRepository;
+exports.UserRepository = UserRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(user_model_1.User.name)),
+    __metadata("design:paramtypes", [Function])
+], UserRepository);

package/dist/services/admin-role.service.d.ts

@@ -0,0 +1,7 @@
+import { RoleRepository } from '../repositories/role.repository';
+export declare class AdminRoleService {
+    private readonly roles;
+    private adminRoleId?;
+    constructor(roles: RoleRepository);
+    loadAdminRoleId(): Promise<string>;
+}

package/dist/services/admin-role.service.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminRoleService = void 0;
+const common_1 = require("@nestjs/common");
+const role_repository_1 = require("../repositories/role.repository");
+let AdminRoleService = class AdminRoleService {
+    constructor(roles) {
+        this.roles = roles;
+    }
+    async loadAdminRoleId() {
+        if (this.adminRoleId)
+            return this.adminRoleId;
+        const admin = await this.roles.findByName('admin');
+        if (!admin)
+            throw new Error('Admin role not seeded.');
+        this.adminRoleId = admin._id.toString();
+        return this.adminRoleId;
+    }
+};
+exports.AdminRoleService = AdminRoleService;
+exports.AdminRoleService = AdminRoleService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [role_repository_1.RoleRepository])
+], AdminRoleService);

package/dist/services/auth.service.d.ts

@@ -0,0 +1,49 @@
+import { UserRepository } from '../repositories/user.repository';
+import { RegisterDto } from '../dtos/auth/register.dto';
+import { LoginDto } from '../dtos/auth/login.dto';
+import { MailService } from './mail.service';
+import { RoleRepository } from '../repositories/role.repository';
+export declare class AuthService {
+    private readonly users;
+    private readonly mail;
+    private readonly roles;
+    constructor(users: UserRepository, mail: MailService, roles: RoleRepository);
+    private resolveExpiry;
+    private signAccessToken;
+    private signRefreshToken;
+    private signEmailToken;
+    private signResetToken;
+    private buildTokenPayload;
+    private getEnv;
+    issueTokensForUser(userId: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    register(dto: RegisterDto): Promise<{
+        id: any;
+        email: string;
+    }>;
+    verifyEmail(token: string): Promise<{
+        ok: boolean;
+    }>;
+    resendVerification(email: string): Promise<{
+        ok: boolean;
+    }>;
+    login(dto: LoginDto): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    refresh(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    forgotPassword(email: string): Promise<{
+        ok: boolean;
+    }>;
+    resetPassword(token: string, newPassword: string): Promise<{
+        ok: boolean;
+    }>;
+    deleteAccount(userId: string): Promise<{
+        ok: boolean;
+    }>;
+}