@loomcore/api 0.2.4 → 0.2.6

package/dist/services/auth.service.js

@@ -1,34 +1,30 @@
-import moment from 'moment';
-import crypto from 'crypto';
-import { EmptyUserContext, passwordValidator, UserSpec, getSystemUserContext } from '@loomcore/common/models';
-import { entityUtils } from '@loomcore/common/utils';
-import { BadRequestError, ServerError } from '../errors/index.js';
-import { JwtService, EmailService } from './index.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
-import { MultiTenantApiService } from './multi-tenant-api.service.js';
-import { PasswordResetTokenService } from './password-reset-token.service.js';
-import { OrganizationService } from './organization.service.js';
-import { passwordUtils } from '../utils/index.js';
-import { config } from '../config/index.js';
-import { refreshTokenModelSpec } from '../models/refresh-token.model.js';
-import { getUserContextAuthorizations } from './utils/getUserContextAuthorizations.util.js';
-import { PersonService } from './person.service.js';
+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;
-    personService;
     constructor(database) {
-        super(database, 'users', 'user', UserSpec);
-        this.refreshTokenService = new GenericApiService(database, 'refresh_tokens', 'refresh_token', refreshTokenModelSpec);
+        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);
-        this.personService = new PersonService(database);
         if (!config.auth) {
-            throw new ServerError('Auth configuration is not set');
+            throw new ServerError("Auth configuration is not set");
         }
         this.authConfig = config.auth;
     }
@@ -37,19 +33,17 @@ export class AuthService extends MultiTenantApiService {
         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');
+            throw new BadRequestError("Invalid Credentials");
         }
         const passwordsMatch = await passwordUtils.comparePasswords(user.password, password);
         if (!passwordsMatch) {
-            throw new BadRequestError('Invalid Credentials');
+            throw new BadRequestError("Invalid Credentials");
         }
-        const person = await this.personService.findOne(EmptyUserContext, { filters: { _id: { eq: user.personId } } });
         const authorizations = await getUserContextAuthorizations(this.database, user);
         const userContext = {
             user: user,
-            person: person ?? undefined,
             organization: organization ?? undefined,
-            authorizations: authorizations
+            authorizations: authorizations,
         };
         const deviceId = this.getAndSetDeviceIdCookie(req, res);
         const loginResponse = await this.logUserIn(userContext, deviceId);
@@ -65,10 +59,9 @@ export class AuthService extends MultiTenantApiService {
             const tokenResponse = {
                 accessToken,
                 refreshToken: refreshTokenObject.token,
-                expiresOn: accessTokenExpiresOn
+                expiresOn: accessTokenExpiresOn,
             };
-            this.updateLastLoggedIn(userContext.user._id)
-                .catch(err => console.log(`Error updating lastLoggedIn: ${err}`));
+            this.updateLastLoggedIn(userContext.user._id).catch((err) => console.log(`Error updating lastLoggedIn: ${err}`));
             userContext.user = this.postProcessEntity(userContext, userContext.user);
             loginResponse = { tokens: tokenResponse, userContext };
         }
@@ -76,44 +69,33 @@ export class AuthService extends MultiTenantApiService {
     }
     async getUserByEmail(email) {
         const queryOptions = { filters: { email: { eq: email.toLowerCase() } } };
-        const rawUser = await this.database.findOne(queryOptions, 'users');
+        const rawUser = await this.database.findOne(queryOptions, "users");
         if (!rawUser) {
             return null;
         }
         return this.database.postProcessEntity(rawUser, this.modelSpec.fullSchema);
     }
-    async createUser(userContext, user, person) {
-        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');
+    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 } } });
+                const org = await this.organizationService.findOne(userContext, {
+                    filters: { _id: { eq: user._orgId } },
+                });
                 if (!org) {
-                    throw new BadRequestError('The specified organization does not exist');
+                    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');
+                throw new BadRequestError("A user with this email address already exists");
             }
         }
-        let personId = user.personId;
-        if (personId && person) {
-            await this.personService.partialUpdateById(userContext, personId, person);
-        }
-        if (!personId && person) {
-            const newPerson = await this.personService.create(userContext, person);
-            if (newPerson) {
-                personId = newPerson._id;
-            }
-            else {
-                throw new ServerError('authService.createUser: Failed to create person');
-            }
-        }
-        user.personId = personId;
         return await this.create(userContext, user);
     }
     async requestTokenUsingRefreshToken(refreshToken, deviceId) {
@@ -122,21 +104,13 @@ export class AuthService extends MultiTenantApiService {
         if (activeRefreshToken) {
             const systemUserContext = getSystemUserContext();
             const user = await this.getById(systemUserContext, activeRefreshToken.userId);
-            const person = await this.personService.findOne(EmptyUserContext, { filters: { _id: { eq: user?.personId } } });
             const organization = await this.organizationService.findOne(EmptyUserContext, { filters: { _id: { eq: user?._orgId } } });
             const authorizations = await getUserContextAuthorizations(this.database, user);
-            let userContext = {
+            const userContext = {
                 user: user,
-                person: person ?? undefined,
                 organization: organization ?? undefined,
-                authorizations: authorizations
+                authorizations: authorizations,
             };
-            if (user.personId) {
-                const person = await this.personService.getById(EmptyUserContext, user.personId);
-                if (person) {
-                    userContext.person = person;
-                }
-            }
             tokens = await this.createNewTokens(userContext, activeRefreshToken);
         }
         return tokens;
@@ -147,7 +121,10 @@ export class AuthService extends MultiTenantApiService {
         return result;
     }
     async changePassword(userContext, queryObject, password) {
-        const updates = { password: password, _lastPasswordChange: moment().utc().toDate() };
+        const updates = {
+            password: password,
+            _lastPasswordChange: moment().utc().toDate(),
+        };
         const updatedUsers = await super.update(userContext, queryObject, updates);
         const result = {
             success: true,
@@ -162,12 +139,12 @@ export class AuthService extends MultiTenantApiService {
         const tokenResponse = {
             accessToken,
             refreshToken: activeRefreshToken.token,
-            expiresOn: accessTokenExpiresOn
+            expiresOn: accessTokenExpiresOn,
         };
         return tokenResponse;
     }
     async getActiveRefreshToken(refreshToken, deviceId) {
-        const refreshTokenResult = await this.refreshTokenService.findOne(EmptyUserContext, { filters: { token: { eq: refreshToken }, deviceId: { eq: deviceId } } });
+        const refreshTokenResult = await this.refreshTokenService.findOne(getSystemUserContext(), { filters: { token: { eq: refreshToken }, deviceId: { eq: deviceId } } });
         let activeRefreshToken = null;
         if (refreshTokenResult) {
             const now = Date.now();
@@ -187,10 +164,10 @@ export class AuthService extends MultiTenantApiService {
             userId,
             expiresOn: expiresOn,
             created: moment().utc().toDate(),
-            createdBy: userId
+            createdBy: userId,
         };
-        const deleteResult = await this.deleteRefreshTokensForDevice(deviceId);
-        const insertResult = await this.refreshTokenService.create(EmptyUserContext, newRefreshToken);
+        await this.deleteRefreshTokensForDevice(deviceId);
+        const insertResult = await this.refreshTokenService.create(getSystemUserContext(), newRefreshToken);
         return insertResult;
     }
     async sendResetPasswordEmail(emailAddress, clientBaseUrl) {
@@ -209,38 +186,42 @@ export class AuthService extends MultiTenantApiService {
         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');
+        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');
+        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(EmptyUserContext, retrievedPasswordResetToken._id.toString());
+        await this.passwordResetTokenService.deleteById(getSystemUserContext(), retrievedPasswordResetToken._id.toString());
         console.log(`passwordResetToken deleted for email: ${lowerCaseEmail}`);
         return result;
     }
     deleteRefreshTokensForDevice(deviceId) {
-        return this.refreshTokenService.deleteMany(EmptyUserContext, { filters: { deviceId: { eq: 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 jwtExpirationInSeconds = typeof jwtExpiryConfig === "string"
+            ? parseInt(jwtExpiryConfig)
+            : jwtExpiryConfig;
         const accessToken = JwtService.sign(userContext, this.authConfig.clientSecret, {
-            expiresIn: jwtExpirationInSeconds
+            expiresIn: jwtExpirationInSeconds,
         });
         return accessToken;
     }
-    ;
     generateRefreshToken() {
-        return crypto.randomBytes(40).toString('hex');
+        return crypto.randomBytes(40).toString("hex");
     }
     generateDeviceId() {
-        return crypto.randomBytes(40).toString('hex');
+        return crypto.randomBytes(40).toString("hex");
     }
     getAndSetDeviceIdCookie(req, res) {
         let isNewDeviceId = false;
-        let deviceId = '';
+        let deviceId = "";
         const deviceIdFromCookie = this.getDeviceIdFromCookie(req);
         if (deviceIdFromCookie) {
             deviceId = deviceIdFromCookie;
@@ -252,14 +233,14 @@ export class AuthService extends MultiTenantApiService {
         if (isNewDeviceId) {
             const cookieOptions = {
                 maxAge: this.authConfig.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
-                httpOnly: true
+                httpOnly: true,
             };
-            res.cookie('deviceId', deviceId, cookieOptions);
+            res.cookie("deviceId", deviceId, cookieOptions);
         }
         return deviceId;
     }
     getDeviceIdFromCookie(req) {
-        return req.cookies['deviceId'];
+        return req.cookies.deviceId;
     }
     getExpiresOnFromSeconds(expiresInSeconds) {
         return Date.now() + expiresInSeconds * 1000;
@@ -272,7 +253,7 @@ export class AuthService extends MultiTenantApiService {
     }
     async preProcessEntity(userContext, entity, isCreate, allowId) {
         if (entity.email) {
-            entity.email = entity.email.toLowerCase();
+            entity.email = entity.email?.toLowerCase();
         }
         if (entity.password) {
             const hash = await passwordUtils.hashPassword(entity.password);
@@ -283,11 +264,14 @@ export class AuthService extends MultiTenantApiService {
     }
     async updateLastLoggedIn(userId) {
         try {
-            const updates = { _lastLoggedIn: moment().utc().toDate() };
+            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/email.service.js

@@ -1,5 +1,5 @@
-import { ServerError } from '../errors/index.js';
-import { config } from '../config/index.js';
+import { config } from "../config/index.js";
+import { ServerError } from "../errors/index.js";
 export class EmailService {
     emailClient;
     constructor() {
@@ -7,7 +7,7 @@ export class EmailService {
             this.emailClient = config.thirdPartyClients.emailClient;
         }
         else {
-            throw new ServerError('Email client is not available. Email client is not set in the config.');
+            throw new ServerError("Email client is not available. Email client is not set in the config.");
         }
     }
     async sendResetPasswordEmail(emailAddress, resetPasswordLink) {
@@ -16,8 +16,8 @@ export class EmailService {
             console.log(`Reset password email sent to ${emailAddress} with reset password link ${resetPasswordLink}`);
         }
         catch (error) {
-            console.error('Error sending reset password email:', error);
-            throw new ServerError('Error sending reset password email');
+            console.error("Error sending reset password email:", error);
+            throw new ServerError("Error sending reset password email");
         }
     }
 }

package/dist/services/jwt.service.js

@@ -1,11 +1,11 @@
-import jwt from 'jsonwebtoken';
+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');
+            throw new Error("JWT secret is required for verification");
         }
         try {
             const decoded = jwt.verify(token, secret);

package/dist/services/multi-tenant-api.service.d.ts

@@ -1,7 +1,7 @@
-import { IUserContext, IEntity, IQueryOptions, IModelSpec } from '@loomcore/common/models';
-import { Operation } from '../databases/operations/operation.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
-import { IDatabase } from '../databases/models/index.js';
+import type { IEntity, IModelSpec, IQueryOptions, IUserContext } from "@loomcore/common/models";
+import type { IDatabase } from "../databases/models/index.js";
+import type { Operation } from "../databases/operations/operation.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 export declare class MultiTenantApiService<T extends IEntity> extends GenericApiService<T> {
     private tenantDecorator?;
     constructor(database: IDatabase, pluralResourceName: string, singularResourceName: string, modelSpec: IModelSpec);

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

@@ -1,7 +1,7 @@
-import { TenantQueryDecorator } from './tenant-query-decorator.js';
-import { BadRequestError } from '../errors/bad-request.error.js';
-import { config } from '../config/base-api-config.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
+import { config } from "../config/base-api-config.js";
+import { BadRequestError } from "../errors/bad-request.error.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+import { TenantQueryDecorator } from "./tenant-query-decorator.js";
 export class MultiTenantApiService extends GenericApiService {
     tenantDecorator;
     constructor(database, pluralResourceName, singularResourceName, modelSpec) {
@@ -11,11 +11,11 @@ export class MultiTenantApiService extends GenericApiService {
         }
     }
     prepareQuery(userContext, queryOptions, operations) {
-        if (!config?.app?.isMultiTenant || userContext?.user?._id === 'system') {
+        if (!config?.app?.isMultiTenant || userContext?.user?._id === "system") {
             return super.prepareQuery(userContext, queryOptions, operations);
         }
         if (!userContext || !userContext.organization?._id) {
-            throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQuery');
+            throw new BadRequestError("A valid userContext was not provided to MultiTenantApiService.prepareQuery");
         }
         const queryObject = this.tenantDecorator.applyTenantToQuery(userContext, queryOptions, this.pluralResourceName);
         return { queryObject, operations };
@@ -25,10 +25,10 @@ export class MultiTenantApiService extends GenericApiService {
             return super.preProcessEntity(userContext, entity, isCreate, allowId);
         }
         if (!userContext || !userContext.organization?._id) {
-            throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
+            throw new BadRequestError("A valid userContext was not provided to MultiTenantApiService.prepareEntity");
         }
         const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate, allowId);
-        if (isCreate && userContext.user._id !== 'system') {
+        if (isCreate && userContext.user._id !== "system") {
             preparedEntity._orgId = userContext.organization?._id;
         }
         return preparedEntity;

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

@@ -1,7 +1,7 @@
-import { IOrganization, IUserContext } from '@loomcore/common/models';
-import { IDatabase } from '../databases/models/database.interface.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
-import { AppIdType } from '@loomcore/common/types';
+import { type IOrganization, type IUserContext } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../databases/models/index.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 export declare class OrganizationService extends GenericApiService<IOrganization> {
     constructor(database: IDatabase);
     preProcessEntity(userContext: IUserContext, entity: Partial<IOrganization>, isCreate: boolean, allowId?: boolean): Promise<Partial<IOrganization>>;

package/dist/services/organization.service.js

@@ -1,18 +1,18 @@
-import { OrganizationSpec } from '@loomcore/common/models';
-import { BadRequestError } from '../errors/index.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
+import { OrganizationSpec, } from "@loomcore/common/models";
+import { BadRequestError } from "../errors/index.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 export class OrganizationService extends GenericApiService {
     constructor(database) {
-        super(database, 'organizations', 'organization', OrganizationSpec);
+        super(database, "organizations", "organization", OrganizationSpec);
     }
     async preProcessEntity(userContext, entity, isCreate, allowId = true) {
         if (isCreate) {
             const metaOrg = await this.getMetaOrg(userContext);
             if (metaOrg && entity.isMetaOrg) {
-                throw new BadRequestError('Meta organization already exists');
+                throw new BadRequestError("Meta organization already exists");
             }
             if (metaOrg && userContext.organization?._id !== metaOrg._id) {
-                throw new BadRequestError('User is not authorized to create an organization');
+                throw new BadRequestError("User is not authorized to create an organization");
             }
         }
         const result = await super.preProcessEntity(userContext, entity, isCreate, allowId);
@@ -23,7 +23,9 @@ export class OrganizationService extends GenericApiService {
         return org?.authToken ?? null;
     }
     async validateRepoAuthToken(userContext, orgCode, authToken) {
-        const org = await this.findOne(userContext, { filters: { code: { eq: orgCode } } });
+        const org = await this.findOne(userContext, {
+            filters: { code: { eq: orgCode } },
+        });
         if (!org) {
             return null;
         }
@@ -31,7 +33,9 @@ export class OrganizationService extends GenericApiService {
         return orgId;
     }
     async getMetaOrg(userContext) {
-        const org = await this.findOne(userContext, { filters: { isMetaOrg: { eq: true } } });
+        const org = await this.findOne(userContext, {
+            filters: { isMetaOrg: { eq: true } },
+        });
         return org;
     }
 }

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

@@ -1,7 +1,7 @@
-import { IPasswordResetToken } from '@loomcore/common/models';
-import { IDatabase } from '../databases/models/index.js';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
-export declare class PasswordResetTokenService extends GenericApiService<IPasswordResetToken> {
+import { type IPasswordResetToken } 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>;

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

@@ -1,21 +1,25 @@
-import crypto from 'crypto';
-import { EmptyUserContext, PasswordResetTokenSpec } from '@loomcore/common/models';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
-export class PasswordResetTokenService extends GenericApiService {
+import crypto from "node:crypto";
+import { getSystemUserContext, 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);
+        super(database, "password_reset_tokens", "password_reset_token", PasswordResetTokenSpec);
     }
     async createPasswordResetToken(email, expiresOn) {
         const lowerCaseEmail = email.toLowerCase();
-        await this.deleteMany(EmptyUserContext, { filters: { email: { eq: lowerCaseEmail } } });
+        await this.deleteMany(getSystemUserContext(), {
+            filters: { email: { eq: lowerCaseEmail } },
+        });
         const passwordResetToken = {
             email: lowerCaseEmail,
-            token: crypto.randomBytes(40).toString('hex'),
+            token: crypto.randomBytes(40).toString("hex"),
             expiresOn: expiresOn,
         };
-        return super.create(EmptyUserContext, passwordResetToken);
+        return super.create(getSystemUserContext(), passwordResetToken);
     }
     async getByEmail(email) {
-        return await super.findOne(EmptyUserContext, { filters: { email: { eq: email.toLowerCase() } } });
+        return await super.findOne(getSystemUserContext(), {
+            filters: { email: { eq: email.toLowerCase() } },
+        });
     }
 }

package/dist/services/tenant-query-decorator.d.ts

@@ -1,4 +1,4 @@
-import { IUserContext, IQueryOptions, IEntity } from '@loomcore/common/models';
+import type { IEntity, IQueryOptions, IUserContext } from "@loomcore/common/models";
 export interface ITenantQueryOptions {
     orgIdField?: string;
     excludedCollections?: string[];

package/dist/services/tenant-query-decorator.js

@@ -1,7 +1,7 @@
-import { ServerError } from '../errors/index.js';
+import { ServerError } from "../errors/index.js";
 export const DEFAULT_TENANT_OPTIONS = {
-    orgIdField: '_orgId',
-    excludedCollections: []
+    orgIdField: "_orgId",
+    excludedCollections: [],
 };
 export class TenantQueryDecorator {
     options;
@@ -13,12 +13,18 @@ export class TenantQueryDecorator {
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
             userContext?.organization?._id;
         if (shouldApplyTenantFilter) {
-            const orgIdField = this.options.orgIdField || '_orgId';
-            result = { ...queryObject, filters: { ...queryObject.filters, [orgIdField]: { eq: userContext.organization?._id } } };
+            const orgIdField = this.options.orgIdField || "_orgId";
+            result = {
+                ...queryObject,
+                filters: {
+                    ...queryObject.filters,
+                    [orgIdField]: { eq: userContext.organization?._id },
+                },
+            };
         }
         else if (!userContext?.organization?._id) {
             if (!this.options.excludedCollections?.includes(collectionName)) {
-                throw new ServerError('No _orgId found in userContext');
+                throw new ServerError("No _orgId found in userContext");
             }
         }
         return result;
@@ -28,7 +34,7 @@ export class TenantQueryDecorator {
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName);
         if (shouldApplyTenantFilter) {
             if (!userContext?.organization?._id) {
-                throw new ServerError('userContext must have an _orgId property to apply tenant filtering');
+                throw new ServerError("userContext must have an _orgId property to apply tenant filtering");
             }
             if (!result.filters) {
                 result.filters = {};
@@ -43,20 +49,20 @@ export class TenantQueryDecorator {
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
             userContext?.organization?._id;
         if (shouldApplyTenantFilter) {
-            const orgIdField = this.options.orgIdField || '_orgId';
+            const orgIdField = this.options.orgIdField || "_orgId";
             result = {
                 ...entity,
-                [orgIdField]: userContext.organization?._id
+                [orgIdField]: userContext.organization?._id,
             };
         }
         else if (!userContext?.organization?._id) {
             if (!this.options.excludedCollections?.includes(collectionName)) {
-                throw new ServerError('No _orgId found in userContext');
+                throw new ServerError("No _orgId found in userContext");
             }
         }
         return result;
     }
     getOrgIdField() {
-        return this.options.orgIdField || '_orgId';
+        return this.options.orgIdField || "_orgId";
     }
 }

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

@@ -1,9 +1,9 @@
-import { IUser, IUserContext } from '@loomcore/common/models';
-import type { AppIdType } from '@loomcore/common/types';
-import { MultiTenantApiService } from './index.js';
-import { IDatabase } from '../databases/models/index.js';
+import { type IUser, type IUserContext } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
+import type { IDatabase } from "../databases/models/index.js";
+import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export declare class UserService extends MultiTenantApiService<IUser> {
     constructor(database: IDatabase);
-    fullUpdateById(userContext: IUserContext, id: AppIdType, entity: IUser): Promise<IUser>;
-    preProcessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId?: boolean): Promise<Partial<IUser>>;
+    fullUpdateById(_userContext: IUserContext, _id: AppIdType, _entity: IUser): Promise<IUser>;
+    preProcessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, _allowId?: boolean): Promise<Partial<IUser>>;
 }

package/dist/services/user.service.js

@@ -1,14 +1,14 @@
-import { UserSpec } from '@loomcore/common/models';
-import { MultiTenantApiService } from './index.js';
-import { ServerError } from '../errors/index.js';
+import { UserSpec, } from "@loomcore/common/models";
+import { ServerError } from "../errors/index.js";
+import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class UserService extends MultiTenantApiService {
     constructor(database) {
-        super(database, 'users', 'user', UserSpec);
+        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.');
+    async fullUpdateById(_userContext, _id, _entity) {
+        throw new ServerError("Cannot full update a user. Either use PATCH or /auth/change-password to update password.");
     }
-    async preProcessEntity(userContext, entity, isCreate, allowId = false) {
+    async preProcessEntity(userContext, entity, isCreate, _allowId = false) {
         const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate);
         if (preparedEntity.email) {
             preparedEntity.email = preparedEntity.email.toLowerCase();

package/dist/services/utils/audit-for-create.util.d.ts

@@ -1,2 +1,2 @@
-import { IUserContext } from "@loomcore/common/models";
+import type { IUserContext } from "@loomcore/common/models";
 export declare function auditForCreate(userContext: IUserContext, doc: any): void;

package/dist/services/utils/audit-for-update.util.d.ts

@@ -1,2 +1,2 @@
-import { IUserContext } from "@loomcore/common/models";
+import type { IUserContext } from "@loomcore/common/models";
 export declare function auditForUpdate(userContext: IUserContext, doc: any): void;