@loomcore/api 0.2.6 → 0.2.8

package/dist/utils/auth/request-token-using-refresh-token.util.d.ts

@@ -0,0 +1,3 @@
+import type { ITokenResponse, IUserContext } from "@loomcore/common/models";
+import type { IDatabase } from "../../databases/models/index.js";
+export declare function requestTokenUsingRefreshToken(database: IDatabase, userContext: IUserContext, refreshToken: string, deviceId: string): Promise<ITokenResponse | null>;

package/dist/utils/auth/request-token-using-refresh-token.util.js

@@ -0,0 +1,9 @@
+import { createNewTokens } from "./create-new-tokens.util.js";
+import { getActiveRefreshToken } from "./get-active-refresh-token.util.js";
+export async function requestTokenUsingRefreshToken(database, userContext, refreshToken, deviceId) {
+    const activeRefreshToken = await getActiveRefreshToken(database, userContext, refreshToken, deviceId);
+    if (activeRefreshToken) {
+        return createNewTokens(userContext, activeRefreshToken);
+    }
+    return null;
+}

package/dist/utils/auth/reset-password.util.d.ts

@@ -0,0 +1,4 @@
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../../databases/models/index.js";
+import type { UpdateResult } from "../../databases/models/update-result.js";
+export declare function resetPassword(database: IDatabase, email: string, passwordResetToken: string, password: string, organizationId?: AppIdType): Promise<UpdateResult>;

package/dist/utils/auth/reset-password.util.js

@@ -0,0 +1,50 @@
+import { EmptyUserContext, passwordValidator, UserSpec, } from "@loomcore/common/models";
+import { entityUtils } from "@loomcore/common/utils";
+import { config } from "../../config/base-api-config.js";
+import { BadRequestError, ServerError } from "../../errors/index.js";
+import { OrganizationService } from "../../services/organization.service.js";
+import { PasswordResetTokenService } from "../../services/password-reset-token.service.js";
+import { UserService } from "../../services/user.service.js";
+import { changePassword } from "./change-password.util.js";
+export async function resetPassword(database, email, passwordResetToken, password, organizationId) {
+    const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
+    entityUtils.handleValidationResult(validationErrors, "AuthService.resetPassword");
+    if (config.app.isMultiTenant && !organizationId) {
+        throw new BadRequestError("Missing required fields: organizationId is required.");
+    }
+    const lowerCaseEmail = email.toLowerCase();
+    const organizationService = new OrganizationService(database);
+    const passwordResetTokenService = new PasswordResetTokenService(database);
+    const userService = new UserService(database);
+    const organization = organizationId
+        ? await organizationService.findOne(EmptyUserContext, {
+            filters: { _id: { eq: organizationId } },
+        })
+        : null;
+    const userContext = {
+        ...EmptyUserContext,
+        organization: organization ?? undefined,
+    };
+    const retrievedPasswordResetToken = await passwordResetTokenService.findOne(userContext, {
+        filters: { email: { eq: lowerCaseEmail } },
+    });
+    if (!retrievedPasswordResetToken) {
+        throw new ServerError(`Unable to retrieve password reset token for email: ${lowerCaseEmail}`);
+    }
+    if (retrievedPasswordResetToken.token !== passwordResetToken ||
+        retrievedPasswordResetToken.expiresOn < Date.now()) {
+        throw new BadRequestError("Invalid password reset token");
+    }
+    const user = await userService.findOne(userContext, {
+        filters: { email: { eq: lowerCaseEmail } },
+    });
+    if (!user) {
+        throw new ServerError(`Unable to retrieve user for email: ${lowerCaseEmail}`);
+    }
+    userContext.user = user;
+    const result = await changePassword(database, userContext, password);
+    console.log(`password changed using forgot-password for email: ${lowerCaseEmail}`);
+    await passwordResetTokenService.deleteById(userContext, retrievedPasswordResetToken._id);
+    console.log(`passwordResetToken deleted for email: ${lowerCaseEmail}`);
+    return result;
+}

package/dist/utils/auth/send-reset-password-email.util.d.ts

@@ -0,0 +1,3 @@
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../../databases/models/index.js";
+export declare function sendResetPasswordEmail(database: IDatabase, emailAddress: string, clientBaseUrl: string, organizationId?: AppIdType): Promise<void>;

package/dist/utils/auth/send-reset-password-email.util.js

@@ -0,0 +1,30 @@
+import { EmptyUserContext, } from "@loomcore/common/models";
+import { ServerError } from "../../errors/index.js";
+import { EmailService } from "../../services/email.service.js";
+import { OrganizationService } from "../../services/organization.service.js";
+import { PasswordResetTokenService } from "../../services/password-reset-token.service.js";
+import { getAuthConfig } from "./get-auth-config.util.js";
+import { getExpiresOnFromMinutes } from "./get-expires-on-from-minutes.util.js";
+export async function sendResetPasswordEmail(database, emailAddress, clientBaseUrl, organizationId) {
+    const authConfig = getAuthConfig();
+    const organizationService = new OrganizationService(database);
+    const passwordResetTokenService = new PasswordResetTokenService(database);
+    const emailService = new EmailService();
+    const organization = organizationId
+        ? await organizationService.findOne(EmptyUserContext, {
+            filters: { _id: { eq: organizationId } },
+        })
+        : null;
+    const userContext = {
+        ...EmptyUserContext,
+        organization: organization ?? undefined,
+    };
+    const expiresOn = getExpiresOnFromMinutes(authConfig.passwordResetTokenExpirationInMinutes);
+    const passwordResetToken = await passwordResetTokenService.createPasswordResetToken(userContext, emailAddress, expiresOn);
+    if (!passwordResetToken) {
+        throw new ServerError(`Failed to create password reset token for email: ${emailAddress}`);
+    }
+    const urlEncodedEmail = encodeURIComponent(emailAddress);
+    const resetPasswordLink = `${clientBaseUrl}/reset-password/${passwordResetToken.token}/${urlEncodedEmail}`;
+    await emailService.sendResetPasswordEmail(emailAddress, resetPasswordLink);
+}

package/dist/utils/auth/update-last-logged-in.util.d.ts

@@ -0,0 +1,3 @@
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../../databases/models/index.js";
+export declare function updateLastLoggedIn(database: IDatabase, userId: AppIdType): Promise<void>;

package/dist/utils/auth/update-last-logged-in.util.js

@@ -0,0 +1,15 @@
+import { getSystemUserContext } from "@loomcore/common/models";
+import moment from "moment";
+import { UserService } from "../../services/user.service.js";
+export async function updateLastLoggedIn(database, userId) {
+    try {
+        const updates = {
+            _lastLoggedIn: moment().utc().toDate(),
+        };
+        const userService = new UserService(database);
+        await userService.update(getSystemUserContext(), { filters: { _id: { eq: userId } } }, updates);
+    }
+    catch (error) {
+        console.error(`Error updating lastLoggedIn: ${error}`);
+    }
+}

package/dist/utils/index.d.ts

@@ -1,6 +1,8 @@
-export * from './address.utils.js';
-export * from './api.utils.js';
-export * from './conversion.utils.js';
-export * from './express.utils.js';
-export * from './password.utils.js';
-export * from './string.utils.js';
+export * from "./address.utils.js";
+export * from "./api.utils.js";
+export * from "./auth/index.js";
+export * from "./conversion.utils.js";
+export * from "./express.utils.js";
+export * from "./jwt.utils.js";
+export * from "./password.utils.js";
+export * from "./string.utils.js";

package/dist/utils/index.js

@@ -1,6 +1,8 @@
-export * from './address.utils.js';
-export * from './api.utils.js';
-export * from './conversion.utils.js';
-export * from './express.utils.js';
-export * from './password.utils.js';
-export * from './string.utils.js';
+export * from "./address.utils.js";
+export * from "./api.utils.js";
+export * from "./auth/index.js";
+export * from "./conversion.utils.js";
+export * from "./express.utils.js";
+export * from "./jwt.utils.js";
+export * from "./password.utils.js";
+export * from "./string.utils.js";

package/dist/utils/jwt.utils.d.ts

@@ -0,0 +1,2 @@
+import type { IUserContext } from "@loomcore/common/models";
+export declare function generateJwt(userContext: IUserContext): string;

package/dist/utils/jwt.utils.js

@@ -0,0 +1,12 @@
+import jwt from "jsonwebtoken";
+import { getAuthConfig } from "./auth/get-auth-config.util.js";
+export function generateJwt(userContext) {
+    const authConfig = getAuthConfig();
+    const jwtExpiryConfig = authConfig.jwtExpirationInSeconds;
+    const jwtExpirationInSeconds = typeof jwtExpiryConfig === "string"
+        ? Number.parseInt(jwtExpiryConfig, 10)
+        : jwtExpiryConfig;
+    return jwt.sign(userContext, authConfig.clientSecret, {
+        expiresIn: jwtExpirationInSeconds,
+    });
+}

package/dist/utils/password.utils.js

@@ -1,23 +1,23 @@
-import { scrypt, randomBytes } from 'node:crypto';
-import { promisify } from 'util';
+import { randomBytes, scrypt } from "node:crypto";
+import { promisify } from "util";
 const scryptAsync = promisify(scrypt);
 async function hashPassword(password) {
-    const salt = randomBytes(8).toString('hex');
+    const salt = randomBytes(8).toString("hex");
     const buf = (await scryptAsync(password, salt, 64));
-    return `${buf.toString('hex')}.${salt}`;
+    return `${buf.toString("hex")}.${salt}`;
 }
 async function comparePasswords(storedPassword, suppliedPassword) {
-    if (!storedPassword || !storedPassword.includes('.')) {
+    if (!storedPassword?.includes(".")) {
         return false;
     }
-    const [hashedPassword, salt] = storedPassword.split('.');
+    const [hashedPassword, salt] = storedPassword.split(".");
     if (!salt) {
         return false;
     }
     const buf = (await scryptAsync(suppliedPassword, salt, 64));
-    return buf.toString('hex') === hashedPassword;
+    return buf.toString("hex") === hashedPassword;
 }
 export const passwordUtils = {
     hashPassword,
-    comparePasswords
+    comparePasswords,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -12,7 +12,7 @@
     "patch": "npm version patch",
     "push": "git push",
     "publishMe": "npm publish --access public",
-    "pub": "npm-run-all -s add commit patch build push publishMe",
+    "pub": "npm-run-all -s patch build push publishMe",
     "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/common",
     "install-updated-libs": "npm i @loomcore/common",
     "update-libs": "npm-run-all -s update-lib-versions install-updated-libs",
@@ -58,7 +58,7 @@
     "qs": "^6.15.2"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.71",
+    "@loomcore/common": "^0.0.72",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

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

@@ -1,49 +0,0 @@
-import { type ILoginResponse, type ITokenResponse, type IUser, type IUserContext } from "@loomcore/common/models";
-import type { AppIdType } from "@loomcore/common/types";
-import type { Request, Response } from "express";
-import type { IDatabase } from "../databases/models/index.js";
-import type { UpdateResult } from "../databases/models/update-result.js";
-import { type IRefreshToken } from "../models/refresh-token.model.js";
-import { MultiTenantApiService } from "./multi-tenant-api.service.js";
-export declare class AuthService extends MultiTenantApiService<IUser> {
-    private refreshTokenService;
-    private passwordResetTokenService;
-    private emailService;
-    private organizationService;
-    private authConfig;
-    constructor(database: IDatabase);
-    attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
-    logUserIn(userContext: IUserContext, deviceId: string): Promise<{
-        tokens: {
-            accessToken: string;
-            refreshToken: string;
-            expiresOn: number;
-        };
-        userContext: IUserContext;
-    } | null>;
-    getUserByEmail(email: string): Promise<IUser | null>;
-    createUser(userContext: IUserContext, user: Partial<IUser>): Promise<IUser | null>;
-    requestTokenUsingRefreshToken(refreshToken: string, deviceId: string): Promise<ITokenResponse | null>;
-    changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult>;
-    changePassword(userContext: IUserContext, queryObject: any, password: string): Promise<UpdateResult>;
-    createNewTokens(userContext: IUserContext, activeRefreshToken: IRefreshToken): Promise<{
-        accessToken: string;
-        refreshToken: string;
-        expiresOn: number;
-    }>;
-    getActiveRefreshToken(refreshToken: string, deviceId: string): Promise<IRefreshToken | null>;
-    createNewRefreshToken(userId: AppIdType, deviceId: string, orgId?: AppIdType): Promise<IRefreshToken | null>;
-    sendResetPasswordEmail(emailAddress: string, clientBaseUrl: string): Promise<void>;
-    resetPassword(email: string, passwordResetToken: string, password: string): Promise<UpdateResult>;
-    deleteRefreshTokensForDevice(deviceId: string): Promise<import("../databases/models/delete-result.js").DeleteResult>;
-    generateJwt(userContext: IUserContext): string;
-    generateRefreshToken(): string;
-    generateDeviceId(): string;
-    getAndSetDeviceIdCookie(req: Request, res: Response): string;
-    getDeviceIdFromCookie(req: Request): any;
-    getExpiresOnFromSeconds(expiresInSeconds: number): number;
-    getExpiresOnFromMinutes(expiresInMinutes: number): number;
-    getExpiresOnFromDays(expiresInDays: number): number;
-    preProcessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId: boolean): Promise<Partial<IUser>>;
-    private updateLastLoggedIn;
-}

package/dist/services/auth.service.js

@@ -1,277 +0,0 @@
-import crypto from "node:crypto";
-import { EmptyUserContext, getSystemUserContext, passwordValidator, UserSpec, } from "@loomcore/common/models";
-import { entityUtils } from "@loomcore/common/utils";
-import moment from "moment";
-import { config } from "../config/index.js";
-import { BadRequestError, ServerError } from "../errors/index.js";
-import { refreshTokenModelSpec, } from "../models/refresh-token.model.js";
-import { passwordUtils } from "../utils/index.js";
-import { EmailService, JwtService } from "./index.js";
-import { MultiTenantApiService } from "./multi-tenant-api.service.js";
-import { OrganizationService } from "./organization.service.js";
-import { PasswordResetTokenService } from "./password-reset-token.service.js";
-import { getUserContextAuthorizations } from "./utils/getUserContextAuthorizations.util.js";
-export class AuthService extends MultiTenantApiService {
-    refreshTokenService;
-    passwordResetTokenService;
-    emailService;
-    organizationService;
-    authConfig;
-    constructor(database) {
-        super(database, "users", "user", UserSpec);
-        this.refreshTokenService = new MultiTenantApiService(database, "refresh_tokens", "refresh_token", refreshTokenModelSpec);
-        this.passwordResetTokenService = new PasswordResetTokenService(database);
-        this.emailService = new EmailService();
-        this.organizationService = new OrganizationService(database);
-        if (!config.auth) {
-            throw new ServerError("Auth configuration is not set");
-        }
-        this.authConfig = config.auth;
-    }
-    async attemptLogin(req, res, email, password) {
-        const lowerCaseEmail = email.toLowerCase();
-        const user = await this.getUserByEmail(lowerCaseEmail);
-        const organization = await this.organizationService.findOne(EmptyUserContext, { filters: { _id: { eq: user?._orgId } } });
-        if (!user) {
-            throw new BadRequestError("Invalid Credentials");
-        }
-        const passwordsMatch = await passwordUtils.comparePasswords(user.password, password);
-        if (!passwordsMatch) {
-            throw new BadRequestError("Invalid Credentials");
-        }
-        const authorizations = await getUserContextAuthorizations(this.database, user);
-        const userContext = {
-            user: user,
-            organization: organization ?? undefined,
-            authorizations: authorizations,
-        };
-        const deviceId = this.getAndSetDeviceIdCookie(req, res);
-        const loginResponse = await this.logUserIn(userContext, deviceId);
-        return loginResponse;
-    }
-    async logUserIn(userContext, deviceId) {
-        const payload = userContext;
-        const accessToken = this.generateJwt(payload);
-        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id, deviceId, userContext.organization?._id);
-        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(this.authConfig.jwtExpirationInSeconds);
-        let loginResponse = null;
-        if (refreshTokenObject) {
-            const tokenResponse = {
-                accessToken,
-                refreshToken: refreshTokenObject.token,
-                expiresOn: accessTokenExpiresOn,
-            };
-            this.updateLastLoggedIn(userContext.user._id).catch((err) => console.log(`Error updating lastLoggedIn: ${err}`));
-            userContext.user = this.postProcessEntity(userContext, userContext.user);
-            loginResponse = { tokens: tokenResponse, userContext };
-        }
-        return loginResponse;
-    }
-    async getUserByEmail(email) {
-        const queryOptions = { filters: { email: { eq: email.toLowerCase() } } };
-        const rawUser = await this.database.findOne(queryOptions, "users");
-        if (!rawUser) {
-            return null;
-        }
-        return this.database.postProcessEntity(rawUser, this.modelSpec.fullSchema);
-    }
-    async createUser(userContext, user) {
-        if (userContext.user._id === "system") {
-            if (config.app.isMultiTenant &&
-                userContext.organization?._id !== user._orgId) {
-                throw new BadRequestError("User is not authorized to create a user in this organization");
-            }
-            if (user._orgId) {
-                const org = await this.organizationService.findOne(userContext, {
-                    filters: { _id: { eq: user._orgId } },
-                });
-                if (!org) {
-                    throw new BadRequestError("The specified organization does not exist");
-                }
-            }
-        }
-        if (user.email) {
-            const existingUser = await this.getUserByEmail(user.email);
-            if (existingUser) {
-                throw new BadRequestError("A user with this email address already exists");
-            }
-        }
-        return await this.create(userContext, user);
-    }
-    async requestTokenUsingRefreshToken(refreshToken, deviceId) {
-        let tokens = null;
-        const activeRefreshToken = await this.getActiveRefreshToken(refreshToken, deviceId);
-        if (activeRefreshToken) {
-            const systemUserContext = getSystemUserContext();
-            const user = await this.getById(systemUserContext, activeRefreshToken.userId);
-            const organization = await this.organizationService.findOne(EmptyUserContext, { filters: { _id: { eq: user?._orgId } } });
-            const authorizations = await getUserContextAuthorizations(this.database, user);
-            const userContext = {
-                user: user,
-                organization: organization ?? undefined,
-                authorizations: authorizations,
-            };
-            tokens = await this.createNewTokens(userContext, activeRefreshToken);
-        }
-        return tokens;
-    }
-    async changeLoggedInUsersPassword(userContext, body) {
-        const queryObject = { _id: userContext.user._id };
-        const result = await this.changePassword(userContext, queryObject, body.password);
-        return result;
-    }
-    async changePassword(userContext, queryObject, password) {
-        const updates = {
-            password: password,
-            _lastPasswordChange: moment().utc().toDate(),
-        };
-        const updatedUsers = await super.update(userContext, queryObject, updates);
-        const result = {
-            success: true,
-            count: updatedUsers.length,
-        };
-        return result;
-    }
-    async createNewTokens(userContext, activeRefreshToken) {
-        const payload = userContext;
-        const accessToken = this.generateJwt(payload);
-        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(this.authConfig.jwtExpirationInSeconds);
-        const tokenResponse = {
-            accessToken,
-            refreshToken: activeRefreshToken.token,
-            expiresOn: accessTokenExpiresOn,
-        };
-        return tokenResponse;
-    }
-    async getActiveRefreshToken(refreshToken, deviceId) {
-        const refreshTokenResult = await this.refreshTokenService.findOne(getSystemUserContext(), { filters: { token: { eq: refreshToken }, deviceId: { eq: deviceId } } });
-        let activeRefreshToken = null;
-        if (refreshTokenResult) {
-            const now = Date.now();
-            const notExpired = refreshTokenResult.expiresOn > now;
-            if (notExpired) {
-                activeRefreshToken = refreshTokenResult;
-            }
-        }
-        return activeRefreshToken;
-    }
-    async createNewRefreshToken(userId, deviceId, orgId) {
-        const expiresOn = this.getExpiresOnFromDays(this.authConfig.refreshTokenExpirationInDays);
-        const newRefreshToken = {
-            _orgId: orgId,
-            token: this.generateRefreshToken(),
-            deviceId,
-            userId,
-            expiresOn: expiresOn,
-            created: moment().utc().toDate(),
-            createdBy: userId,
-        };
-        await this.deleteRefreshTokensForDevice(deviceId);
-        const insertResult = await this.refreshTokenService.create(getSystemUserContext(), newRefreshToken);
-        return insertResult;
-    }
-    async sendResetPasswordEmail(emailAddress, clientBaseUrl) {
-        const expiresOn = this.getExpiresOnFromMinutes(this.authConfig.passwordResetTokenExpirationInMinutes);
-        const passwordResetToken = await this.passwordResetTokenService.createPasswordResetToken(emailAddress, expiresOn);
-        if (!passwordResetToken) {
-            throw new ServerError(`Failed to create password reset token for email: ${emailAddress}`);
-        }
-        const urlEncodedEmail = encodeURIComponent(emailAddress);
-        const resetPasswordLink = `${clientBaseUrl}/reset-password/${passwordResetToken.token}/${urlEncodedEmail}`;
-        await this.emailService.sendResetPasswordEmail(emailAddress, resetPasswordLink);
-    }
-    async resetPassword(email, passwordResetToken, password) {
-        const lowerCaseEmail = email.toLowerCase();
-        const retrievedPasswordResetToken = await this.passwordResetTokenService.getByEmail(lowerCaseEmail);
-        if (!retrievedPasswordResetToken) {
-            throw new ServerError(`Unable to retrieve password reset token for email: ${lowerCaseEmail}`);
-        }
-        if (retrievedPasswordResetToken.token !== passwordResetToken ||
-            retrievedPasswordResetToken.expiresOn < Date.now()) {
-            throw new BadRequestError("Invalid password reset token");
-        }
-        const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
-        entityUtils.handleValidationResult(validationErrors, "AuthService.resetPassword");
-        const result = await this.changePassword(getSystemUserContext(), { email: lowerCaseEmail }, password);
-        console.log(`password changed using forgot-password for email: ${lowerCaseEmail}`);
-        await this.passwordResetTokenService.deleteById(getSystemUserContext(), retrievedPasswordResetToken._id.toString());
-        console.log(`passwordResetToken deleted for email: ${lowerCaseEmail}`);
-        return result;
-    }
-    deleteRefreshTokensForDevice(deviceId) {
-        return this.refreshTokenService.deleteMany(getSystemUserContext(), {
-            filters: { deviceId: { eq: deviceId } },
-        });
-    }
-    generateJwt(userContext) {
-        const jwtExpiryConfig = this.authConfig.jwtExpirationInSeconds;
-        const jwtExpirationInSeconds = typeof jwtExpiryConfig === "string"
-            ? parseInt(jwtExpiryConfig)
-            : jwtExpiryConfig;
-        const accessToken = JwtService.sign(userContext, this.authConfig.clientSecret, {
-            expiresIn: jwtExpirationInSeconds,
-        });
-        return accessToken;
-    }
-    generateRefreshToken() {
-        return crypto.randomBytes(40).toString("hex");
-    }
-    generateDeviceId() {
-        return crypto.randomBytes(40).toString("hex");
-    }
-    getAndSetDeviceIdCookie(req, res) {
-        let isNewDeviceId = false;
-        let deviceId = "";
-        const deviceIdFromCookie = this.getDeviceIdFromCookie(req);
-        if (deviceIdFromCookie) {
-            deviceId = deviceIdFromCookie;
-        }
-        else {
-            deviceId = this.generateDeviceId();
-            isNewDeviceId = true;
-        }
-        if (isNewDeviceId) {
-            const cookieOptions = {
-                maxAge: this.authConfig.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
-                httpOnly: true,
-            };
-            res.cookie("deviceId", deviceId, cookieOptions);
-        }
-        return deviceId;
-    }
-    getDeviceIdFromCookie(req) {
-        return req.cookies.deviceId;
-    }
-    getExpiresOnFromSeconds(expiresInSeconds) {
-        return Date.now() + expiresInSeconds * 1000;
-    }
-    getExpiresOnFromMinutes(expiresInMinutes) {
-        return Date.now() + expiresInMinutes * 60 * 1000;
-    }
-    getExpiresOnFromDays(expiresInDays) {
-        return Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
-    }
-    async preProcessEntity(userContext, entity, isCreate, allowId) {
-        if (entity.email) {
-            entity.email = entity.email?.toLowerCase();
-        }
-        if (entity.password) {
-            const hash = await passwordUtils.hashPassword(entity.password);
-            entity.password = hash;
-        }
-        const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate, allowId);
-        return preparedEntity;
-    }
-    async updateLastLoggedIn(userId) {
-        try {
-            const updates = {
-                _lastLoggedIn: moment().utc().toDate(),
-            };
-            const systemUserContext = getSystemUserContext();
-            await this.partialUpdateById(systemUserContext, userId, updates);
-        }
-        catch (error) {
-            console.error(`Error updating lastLoggedIn: ${error}`);
-        }
-    }
-}

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

@@ -1,4 +0,0 @@
-export declare class JwtService {
-    static sign(payload: any, secret: string, options: any): string;
-    static verify(token: string, secret: string): any;
-}

package/dist/services/jwt.service.js

@@ -1,18 +0,0 @@
-import jwt from "jsonwebtoken";
-export class JwtService {
-    static sign(payload, secret, options) {
-        return jwt.sign(payload, secret, options);
-    }
-    static verify(token, secret) {
-        if (!secret) {
-            throw new Error("JWT secret is required for verification");
-        }
-        try {
-            const decoded = jwt.verify(token, secret);
-            return decoded;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}