@loomcore/api 0.2.7 → 0.2.9

package/dist/services/generic-api-service/generic-api.service.js

@@ -1,10 +1,10 @@
-import _ from 'lodash';
-import { DefaultQueryOptions } from '@loomcore/common/models';
-import { entityUtils } from '@loomcore/common/utils';
-import { stripSenderProvidedSystemProperties } from '../utils/strip-sender-provided-system-properties.util.js';
-import { auditForCreate } from '../utils/audit-for-create.util.js';
-import { auditForUpdate } from '../utils/audit-for-update.util.js';
-import { IdNotFoundError, ServerError } from '../../errors/index.js';
+import { DefaultQueryOptions, } from "@loomcore/common/models";
+import { entityUtils } from "@loomcore/common/utils";
+import _ from "lodash";
+import { IdNotFoundError, ServerError } from "../../errors/index.js";
+import { auditForCreate } from "../utils/audit-for-create.util.js";
+import { auditForUpdate } from "../utils/audit-for-update.util.js";
+import { stripSenderProvidedSystemProperties } from "../utils/strip-sender-provided-system-properties.util.js";
 export class GenericApiService {
     database;
     pluralResourceName;
@@ -25,7 +25,7 @@ export class GenericApiService {
             operations = this.prepareQuery(userContext, {}, []).operations;
         }
         const entities = await this.database.getAll(operations, this.pluralResourceName);
-        return entities.map(entity => {
+        return entities.map((entity) => {
             const dbProcessed = this.postProcessEntity(userContext, entity);
             if (postProcessEntityCustom) {
                 return postProcessEntityCustom(userContext, dbProcessed);
@@ -83,7 +83,7 @@ export class GenericApiService {
             operations = this.prepareQuery(userContext, {}, []).operations;
         }
         const pagedResult = await this.database.get(operations, preparedOptions, this.modelSpec, this.pluralResourceName);
-        const transformedEntities = (pagedResult.entities || []).map(entity => {
+        const transformedEntities = (pagedResult.entities || []).map((entity) => {
             const transformedEntity = this.postProcessEntity(userContext, entity);
             if (postProcessEntityCustom) {
                 return postProcessEntityCustom(userContext, transformedEntity);
@@ -92,7 +92,7 @@ export class GenericApiService {
         });
         return {
             ...pagedResult,
-            entities: transformedEntities
+            entities: transformedEntities,
         };
     }
     prepareQueryOptions(userContext, queryOptions) {
@@ -139,10 +139,10 @@ export class GenericApiService {
     async createMany(userContext, entities) {
         let createdEntities = [];
         if (entities.length) {
-            const preparedEntities = await Promise.all(entities.map(entity => this.preProcessEntity(userContext, entity, true, true)));
+            const preparedEntities = await Promise.all(entities.map((entity) => this.preProcessEntity(userContext, entity, true, true)));
             const insertResult = await this.database.createMany(preparedEntities, this.pluralResourceName);
             if (insertResult.insertedIds) {
-                createdEntities = insertResult.entities.map(entity => this.postProcessEntity(userContext, entity));
+                createdEntities = insertResult.entities.map((entity) => this.postProcessEntity(userContext, entity));
             }
         }
         return createdEntities;
@@ -151,10 +151,10 @@ export class GenericApiService {
         if (!entities || entities.length === 0) {
             return [];
         }
-        const preparedEntities = await Promise.all(entities.map(entity => this.preProcessEntity(userContext, entity, false, true)));
+        const preparedEntities = await Promise.all(entities.map((entity) => this.preProcessEntity(userContext, entity, false, true)));
         const { queryObject, operations } = this.prepareQuery(userContext, {}, []);
         const rawUpdatedEntities = await this.database.batchUpdate(preparedEntities, operations, queryObject, this.pluralResourceName);
-        const updatedEntities = rawUpdatedEntities.map(entity => this.postProcessEntity(userContext, entity));
+        const updatedEntities = rawUpdatedEntities.map((entity) => this.postProcessEntity(userContext, entity));
         return updatedEntities;
     }
     async fullUpdateById(userContext, id, entity) {
@@ -189,7 +189,7 @@ export class GenericApiService {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
         const preparedEntity = await this.preProcessEntity(userContext, entity, false, true);
         const rawUpdatedEntities = await this.database.update(preparedQuery, preparedEntity, operations, this.pluralResourceName);
-        const updatedEntities = rawUpdatedEntities.map(entity => this.postProcessEntity(userContext, entity));
+        const updatedEntities = rawUpdatedEntities.map((entity) => this.postProcessEntity(userContext, entity));
         return updatedEntities;
     }
     async deleteById(userContext, id) {
@@ -207,7 +207,7 @@ export class GenericApiService {
     async find(userContext, queryObject) {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
         const rawEntities = await this.database.find(preparedQuery, this.pluralResourceName);
-        return rawEntities.map(entity => this.postProcessEntity(userContext, entity));
+        return rawEntities.map((entity) => this.postProcessEntity(userContext, entity));
     }
     async findOne(userContext, queryObject) {
         const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);

package/dist/services/index.d.ts

@@ -1,12 +1,11 @@
-export * from './auth.service.js';
-export * from './email.service.js';
-export * from './generic-api-service/generic-api.service.js';
-export * from './generic-api-service/generic-api-service.interface.js';
-export * from './generic-query-service/generic-query.service.js';
-export * from './generic-query-service/generic-query-service.interface.js';
-export * from './jwt.service.js';
-export * from './multi-tenant-api.service.js';
-export * from './organization.service.js';
-export * from './password-reset-token.service.js';
-export * from './tenant-query-decorator.js';
-export * from './user.service.js';
+export * from "./email.service.js";
+export * from "./generic-api-service/generic-api.service.js";
+export * from "./generic-api-service/generic-api-service.interface.js";
+export * from "./generic-query-service/generic-query.service.js";
+export * from "./generic-query-service/generic-query-service.interface.js";
+export * from "./multi-tenant-api.service.js";
+export * from "./organization.service.js";
+export * from "./password-reset-token.service.js";
+export * from "./refresh-token.service.js";
+export * from "./tenant-query-decorator.js";
+export * from "./user.service.js";

package/dist/services/index.js

@@ -1,12 +1,11 @@
-export * from './auth.service.js';
-export * from './email.service.js';
-export * from './generic-api-service/generic-api.service.js';
-export * from './generic-api-service/generic-api-service.interface.js';
-export * from './generic-query-service/generic-query.service.js';
-export * from './generic-query-service/generic-query-service.interface.js';
-export * from './jwt.service.js';
-export * from './multi-tenant-api.service.js';
-export * from './organization.service.js';
-export * from './password-reset-token.service.js';
-export * from './tenant-query-decorator.js';
-export * from './user.service.js';
+export * from "./email.service.js";
+export * from "./generic-api-service/generic-api.service.js";
+export * from "./generic-api-service/generic-api-service.interface.js";
+export * from "./generic-query-service/generic-query.service.js";
+export * from "./generic-query-service/generic-query-service.interface.js";
+export * from "./multi-tenant-api.service.js";
+export * from "./organization.service.js";
+export * from "./password-reset-token.service.js";
+export * from "./refresh-token.service.js";
+export * from "./tenant-query-decorator.js";
+export * from "./user.service.js";

package/dist/services/multi-tenant-api.service.js

@@ -1,5 +1,6 @@
 import { config } from "../config/base-api-config.js";
 import { BadRequestError } from "../errors/bad-request.error.js";
+import { ServerError } from "../errors/index.js";
 import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 import { TenantQueryDecorator } from "./tenant-query-decorator.js";
 export class MultiTenantApiService extends GenericApiService {
@@ -14,9 +15,12 @@ export class MultiTenantApiService extends GenericApiService {
         if (!config?.app?.isMultiTenant || userContext?.user?._id === "system") {
             return super.prepareQuery(userContext, queryOptions, operations);
         }
-        if (!userContext || !userContext.organization?._id) {
+        if (!userContext?.organization?._id) {
             throw new BadRequestError("A valid userContext was not provided to MultiTenantApiService.prepareQuery");
         }
+        if (!this.tenantDecorator) {
+            throw new ServerError("A valid tenantDecorator was not provided to MultiTenantApiService.prepareQuery");
+        }
         const queryObject = this.tenantDecorator.applyTenantToQuery(userContext, queryOptions, this.pluralResourceName);
         return { queryObject, operations };
     }
@@ -24,7 +28,7 @@ export class MultiTenantApiService extends GenericApiService {
         if (!config?.app?.isMultiTenant) {
             return super.preProcessEntity(userContext, entity, isCreate, allowId);
         }
-        if (!userContext || !userContext.organization?._id) {
+        if (!userContext?.organization?._id) {
             throw new BadRequestError("A valid userContext was not provided to MultiTenantApiService.prepareEntity");
         }
         const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate, allowId);

package/dist/services/password-reset-token.service.d.ts

@@ -1,8 +1,7 @@
-import { type IPasswordResetToken } from "@loomcore/common/models";
+import { type IPasswordResetToken, type IUserContext } from "@loomcore/common/models";
 import type { IDatabase } from "../databases/models/index.js";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export declare class PasswordResetTokenService extends MultiTenantApiService<IPasswordResetToken> {
     constructor(database: IDatabase);
-    createPasswordResetToken(email: string, expiresOn: number): Promise<IPasswordResetToken | null>;
-    getByEmail(email: string): Promise<IPasswordResetToken | null>;
+    createPasswordResetToken(userContext: IUserContext, email: string, expiresOn: number): Promise<IPasswordResetToken | null>;
 }

package/dist/services/password-reset-token.service.js

@@ -1,13 +1,13 @@
 import crypto from "node:crypto";
-import { getSystemUserContext, PasswordResetTokenSpec, } from "@loomcore/common/models";
+import { PasswordResetTokenSpec, } from "@loomcore/common/models";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class PasswordResetTokenService extends MultiTenantApiService {
     constructor(database) {
         super(database, "password_reset_tokens", "password_reset_token", PasswordResetTokenSpec);
     }
-    async createPasswordResetToken(email, expiresOn) {
+    async createPasswordResetToken(userContext, email, expiresOn) {
         const lowerCaseEmail = email.toLowerCase();
-        await this.deleteMany(getSystemUserContext(), {
+        await this.deleteMany(userContext, {
             filters: { email: { eq: lowerCaseEmail } },
         });
         const passwordResetToken = {
@@ -15,11 +15,6 @@ export class PasswordResetTokenService extends MultiTenantApiService {
             token: crypto.randomBytes(40).toString("hex"),
             expiresOn: expiresOn,
         };
-        return super.create(getSystemUserContext(), passwordResetToken);
-    }
-    async getByEmail(email) {
-        return await super.findOne(getSystemUserContext(), {
-            filters: { email: { eq: email.toLowerCase() } },
-        });
+        return super.create(userContext, passwordResetToken);
     }
 }

package/dist/services/refresh-token.service.d.ts

@@ -0,0 +1,6 @@
+import type { IDatabase } from "../databases/models/index.js";
+import { type IRefreshToken } from "../models/refresh-token.model.js";
+import { MultiTenantApiService } from "./multi-tenant-api.service.js";
+export declare class RefreshTokenService extends MultiTenantApiService<IRefreshToken> {
+    constructor(database: IDatabase);
+}

package/dist/services/refresh-token.service.js

@@ -0,0 +1,7 @@
+import { refreshTokenModelSpec, } from "../models/refresh-token.model.js";
+import { MultiTenantApiService } from "./multi-tenant-api.service.js";
+export class RefreshTokenService extends MultiTenantApiService {
+    constructor(database) {
+        super(database, "refresh_tokens", "refresh_token", refreshTokenModelSpec);
+    }
+}

package/dist/services/user.service.js

@@ -1,21 +1,21 @@
 import { UserSpec, } from "@loomcore/common/models";
 import { ServerError } from "../errors/index.js";
+import { passwordUtils } from "../utils/password.utils.js";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class UserService extends MultiTenantApiService {
     constructor(database) {
         super(database, "users", "user", UserSpec);
     }
     async fullUpdateById(_userContext, _id, _entity) {
-        throw new ServerError("Cannot full update a user. Either use PATCH or /auth/change-password to update password.");
+        throw new ServerError("User full update is not allowed.");
     }
     async preProcessEntity(userContext, entity, isCreate, _allowId = false) {
         const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate);
         if (preparedEntity.email) {
             preparedEntity.email = preparedEntity.email.toLowerCase();
         }
-        if (!isCreate) {
-            const { password, ...cleanedEntity } = preparedEntity;
-            return cleanedEntity;
+        if (preparedEntity.password) {
+            preparedEntity.password = await passwordUtils.hashPassword(preparedEntity.password);
         }
         return preparedEntity;
     }

package/dist/utils/auth/attempt-login.util.d.ts

@@ -0,0 +1,3 @@
+import { type ILoginResponse, type IOrganization } from "@loomcore/common/models";
+import type { IDatabase } from "../../databases/models/index.js";
+export declare function attemptLogin(database: IDatabase, email: string, password: string, deviceId: string, organization: IOrganization | null): Promise<ILoginResponse | null>;

package/dist/utils/auth/attempt-login.util.js

@@ -0,0 +1,37 @@
+import { EmptyUserContext, } from "@loomcore/common/models";
+import { BadRequestError } from "../../errors/index.js";
+import { UserService } from "../../services/user.service.js";
+import { getUserContextAuthorizations } from "../../services/utils/getUserContextAuthorizations.util.js";
+import { passwordUtils } from "../password.utils.js";
+import { logUserIn } from "./log-user-in.util.js";
+export async function attemptLogin(database, email, password, deviceId, organization) {
+    const lowerCaseEmail = email.toLowerCase();
+    const userContext = {
+        ...EmptyUserContext,
+        organization: organization ?? undefined,
+    };
+    const userService = new UserService(database);
+    const user = await userService.findOne(userContext, {
+        filters: {
+            email: { eq: lowerCaseEmail },
+        },
+    });
+    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(database, user);
+    const authenticatedUserContext = {
+        user: user,
+        organization: organization ?? undefined,
+        authorizations: authorizations,
+    };
+    const tokens = await logUserIn(database, authenticatedUserContext, deviceId);
+    return {
+        tokens,
+        userContext: authenticatedUserContext,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { IUserContext } from "@loomcore/common/models";
+import type { IDatabase } from "../../databases/models/index.js";
+import type { UpdateResult } from "../../databases/models/update-result.js";
+export declare function changePassword(database: IDatabase, userContext: IUserContext, password: string): Promise<UpdateResult>;

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

@@ -0,0 +1,14 @@
+import moment from "moment";
+import { UserService } from "../../services/user.service.js";
+export async function changePassword(database, userContext, password) {
+    const userService = new UserService(database);
+    const updates = {
+        password: password,
+        _lastPasswordChange: moment().utc().toDate(),
+    };
+    await userService.partialUpdateById(userContext, userContext.user._id, updates);
+    return {
+        success: true,
+        count: 1,
+    };
+}

package/dist/utils/auth/create-new-refresh-token.util.d.ts

@@ -0,0 +1,4 @@
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../../databases/models/index.js";
+import type { IRefreshToken } from "../../models/refresh-token.model.js";
+export declare function createNewRefreshToken(database: IDatabase, userId: AppIdType, deviceId: string, orgId?: AppIdType): Promise<IRefreshToken>;

package/dist/utils/auth/create-new-refresh-token.util.js

@@ -0,0 +1,29 @@
+import { getSystemUserContext } from "@loomcore/common/models";
+import moment from "moment";
+import { ServerError } from "../../errors/index.js";
+import { RefreshTokenService } from "../../services/refresh-token.service.js";
+import { generateRefreshToken } from "./generate-refresh-token.util.js";
+import { getAuthConfig } from "./get-auth-config.util.js";
+import { getExpiresOnFromDays } from "./get-expires-on-from-days.util.js";
+export async function createNewRefreshToken(database, userId, deviceId, orgId) {
+    const authConfig = getAuthConfig();
+    const expiresOn = getExpiresOnFromDays(authConfig.refreshTokenExpirationInDays);
+    const newRefreshToken = {
+        _orgId: orgId,
+        token: generateRefreshToken(),
+        deviceId,
+        userId,
+        expiresOn: expiresOn,
+        created: moment().utc().toDate(),
+        createdBy: userId,
+    };
+    const refreshTokenService = new RefreshTokenService(database);
+    await refreshTokenService.deleteMany(getSystemUserContext(), {
+        filters: { deviceId: { eq: deviceId } },
+    });
+    const insertResult = await refreshTokenService.create(getSystemUserContext(), newRefreshToken);
+    if (!insertResult) {
+        throw new ServerError("Failed to create refresh token");
+    }
+    return insertResult;
+}

package/dist/utils/auth/create-new-tokens.util.d.ts

@@ -0,0 +1,3 @@
+import type { ITokenResponse, IUserContext } from "@loomcore/common/models";
+import type { IRefreshToken } from "../../models/refresh-token.model.js";
+export declare function createNewTokens(userContext: IUserContext, activeRefreshToken: IRefreshToken): Promise<ITokenResponse>;

package/dist/utils/auth/create-new-tokens.util.js

@@ -0,0 +1,13 @@
+import { generateJwt } from "../jwt.utils.js";
+import { getAuthConfig } from "./get-auth-config.util.js";
+import { getExpiresOnFromSeconds } from "./get-expires-on-from-seconds.util.js";
+export async function createNewTokens(userContext, activeRefreshToken) {
+    const authConfig = getAuthConfig();
+    const accessToken = generateJwt(userContext);
+    const accessTokenExpiresOn = getExpiresOnFromSeconds(authConfig.jwtExpirationInSeconds);
+    return {
+        accessToken,
+        refreshToken: activeRefreshToken.token,
+        expiresOn: accessTokenExpiresOn,
+    };
+}

package/dist/utils/auth/generate-device-id.util.d.ts

@@ -0,0 +1 @@
+export declare function generateDeviceId(): string;

package/dist/utils/auth/generate-device-id.util.js

@@ -0,0 +1,4 @@
+import crypto from "node:crypto";
+export function generateDeviceId() {
+    return crypto.randomBytes(40).toString("hex");
+}

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

@@ -0,0 +1 @@
+export declare function generateRefreshToken(): string;

package/dist/utils/auth/generate-refresh-token.util.js

@@ -0,0 +1,4 @@
+import crypto from "node:crypto";
+export function generateRefreshToken() {
+    return crypto.randomBytes(40).toString("hex");
+}

package/dist/utils/auth/get-active-refresh-token.util.d.ts

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

package/dist/utils/auth/get-active-refresh-token.util.js

@@ -0,0 +1,19 @@
+import { RefreshTokenService } from "../../services/refresh-token.service.js";
+export async function getActiveRefreshToken(database, userContext, refreshToken, deviceId) {
+    const refreshTokenService = new RefreshTokenService(database);
+    const refreshTokenResult = await refreshTokenService.findOne(userContext, {
+        filters: {
+            token: { eq: refreshToken },
+            deviceId: { eq: deviceId },
+        },
+    });
+    if (!refreshTokenResult) {
+        return null;
+    }
+    const now = Date.now();
+    const isExpired = refreshTokenResult.expiresOn < now;
+    if (isExpired) {
+        return null;
+    }
+    return refreshTokenResult;
+}

package/dist/utils/auth/get-and-set-device-id-cookie.util.d.ts

@@ -0,0 +1,2 @@
+import type { Request, Response } from "express";
+export declare function getAndSetDeviceIdCookie(req: Request, res: Response): string;

package/dist/utils/auth/get-and-set-device-id-cookie.util.js

@@ -0,0 +1,23 @@
+import { generateDeviceId } from "./generate-device-id.util.js";
+import { getAuthConfig } from "./get-auth-config.util.js";
+import { getDeviceIdFromCookie } from "./get-device-id-from-cookie.util.js";
+export function getAndSetDeviceIdCookie(req, res) {
+    let deviceId;
+    const deviceIdFromCookie = getDeviceIdFromCookie(req);
+    const isNewDeviceId = !deviceIdFromCookie;
+    if (deviceIdFromCookie) {
+        deviceId = deviceIdFromCookie;
+    }
+    else {
+        deviceId = generateDeviceId();
+    }
+    if (isNewDeviceId) {
+        const authConfig = getAuthConfig();
+        const cookieOptions = {
+            maxAge: authConfig.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
+            httpOnly: true,
+        };
+        res.cookie("deviceId", deviceId, cookieOptions);
+    }
+    return deviceId;
+}

package/dist/utils/auth/get-auth-config.util.d.ts

@@ -0,0 +1,2 @@
+import type { IAuthConfig } from "../../models/auth-config.interface.js";
+export declare function getAuthConfig(): IAuthConfig;

package/dist/utils/auth/get-auth-config.util.js

@@ -0,0 +1,8 @@
+import { config } from "../../config/index.js";
+import { ServerError } from "../../errors/index.js";
+export function getAuthConfig() {
+    if (!config.auth) {
+        throw new ServerError("Auth configuration is not set");
+    }
+    return config.auth;
+}

package/dist/utils/auth/get-device-id-from-cookie.util.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from "express";
+export declare function getDeviceIdFromCookie(req: Request): any;

package/dist/utils/auth/get-device-id-from-cookie.util.js

@@ -0,0 +1,3 @@
+export function getDeviceIdFromCookie(req) {
+    return req.cookies.deviceId;
+}

package/dist/utils/auth/get-expires-on-from-days.util.d.ts

@@ -0,0 +1 @@
+export declare function getExpiresOnFromDays(expiresInDays: number): number;

package/dist/utils/auth/get-expires-on-from-days.util.js

@@ -0,0 +1,3 @@
+export function getExpiresOnFromDays(expiresInDays) {
+    return Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
+}

package/dist/utils/auth/get-expires-on-from-minutes.util.d.ts

@@ -0,0 +1 @@
+export declare function getExpiresOnFromMinutes(expiresInMinutes: number): number;

package/dist/utils/auth/get-expires-on-from-minutes.util.js

@@ -0,0 +1,3 @@
+export function getExpiresOnFromMinutes(expiresInMinutes) {
+    return Date.now() + expiresInMinutes * 60 * 1000;
+}

package/dist/utils/auth/get-expires-on-from-seconds.util.d.ts

@@ -0,0 +1 @@
+export declare function getExpiresOnFromSeconds(expiresInSeconds: number): number;

package/dist/utils/auth/get-expires-on-from-seconds.util.js

@@ -0,0 +1,3 @@
+export function getExpiresOnFromSeconds(expiresInSeconds) {
+    return Date.now() + expiresInSeconds * 1000;
+}

package/dist/utils/auth/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./attempt-login.util.js";
+export * from "./change-password.util.js";
+export * from "./create-new-refresh-token.util.js";
+export * from "./create-new-tokens.util.js";
+export * from "./generate-device-id.util.js";
+export * from "./generate-refresh-token.util.js";
+export * from "./get-active-refresh-token.util.js";
+export * from "./get-and-set-device-id-cookie.util.js";
+export * from "./get-auth-config.util.js";
+export * from "./get-device-id-from-cookie.util.js";
+export * from "./get-expires-on-from-days.util.js";
+export * from "./get-expires-on-from-minutes.util.js";
+export * from "./get-expires-on-from-seconds.util.js";
+export * from "./log-user-in.util.js";
+export * from "./request-token-using-refresh-token.util.js";
+export * from "./reset-password.util.js";
+export * from "./send-reset-password-email.util.js";
+export * from "./update-last-logged-in.util.js";

package/dist/utils/auth/index.js

@@ -0,0 +1,18 @@
+export * from "./attempt-login.util.js";
+export * from "./change-password.util.js";
+export * from "./create-new-refresh-token.util.js";
+export * from "./create-new-tokens.util.js";
+export * from "./generate-device-id.util.js";
+export * from "./generate-refresh-token.util.js";
+export * from "./get-active-refresh-token.util.js";
+export * from "./get-and-set-device-id-cookie.util.js";
+export * from "./get-auth-config.util.js";
+export * from "./get-device-id-from-cookie.util.js";
+export * from "./get-expires-on-from-days.util.js";
+export * from "./get-expires-on-from-minutes.util.js";
+export * from "./get-expires-on-from-seconds.util.js";
+export * from "./log-user-in.util.js";
+export * from "./request-token-using-refresh-token.util.js";
+export * from "./reset-password.util.js";
+export * from "./send-reset-password-email.util.js";
+export * from "./update-last-logged-in.util.js";

package/dist/utils/auth/log-user-in.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 logUserIn(database: IDatabase, userContext: IUserContext, deviceId: string): Promise<ITokenResponse>;

package/dist/utils/auth/log-user-in.util.js

@@ -0,0 +1,18 @@
+import { generateJwt } from "../jwt.utils.js";
+import { createNewRefreshToken } from "./create-new-refresh-token.util.js";
+import { getAuthConfig } from "./get-auth-config.util.js";
+import { getExpiresOnFromSeconds } from "./get-expires-on-from-seconds.util.js";
+import { updateLastLoggedIn } from "./update-last-logged-in.util.js";
+export async function logUserIn(database, userContext, deviceId) {
+    const authConfig = getAuthConfig();
+    const accessToken = generateJwt(userContext);
+    const refreshTokenObject = await createNewRefreshToken(database, userContext.user._id, deviceId, userContext.organization?._id);
+    const accessTokenExpiresOn = getExpiresOnFromSeconds(authConfig.jwtExpirationInSeconds);
+    const tokenResponse = {
+        accessToken,
+        refreshToken: refreshTokenObject.token,
+        expiresOn: accessTokenExpiresOn,
+    };
+    updateLastLoggedIn(database, userContext.user._id).catch((err) => console.log(`Error updating lastLoggedIn: ${err}`));
+    return tokenResponse;
+}

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 IOrganization } from "@loomcore/common/models";
+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, organization: IOrganization | null): Promise<UpdateResult>;