@loomcore/api 0.0.13 → 0.0.16

package/dist/__tests__/test-express-app.js

@@ -39,7 +39,7 @@ export class TestExpressApp {
             debug: {
                 showErrors: false
             },
-            app: { multiTenant: true },
+            app: { isMultiTenant: true },
             auth: {
                 jwtExpirationInSeconds: 3600,
                 refreshTokenExpirationInDays: 7,

package/dist/models/base-api-config.interface.d.ts

@@ -15,7 +15,7 @@ export interface IBaseApiConfig {
         showErrors?: boolean;
     };
     app: {
-        multiTenant: boolean;
+        isMultiTenant: boolean;
     };
     auth: {
         jwtExpirationInSeconds: number;

package/dist/services/auth.service.js

@@ -66,7 +66,7 @@ export class AuthService extends GenericApiService {
         });
     }
     getUserByEmail(email) {
-        return this.collection.findOne({ email: email })
+        return this.collection.findOne({ email: email.toLowerCase() })
             .then((user) => {
             return user;
         });
@@ -176,17 +176,18 @@ export class AuthService extends GenericApiService {
         await this.emailService.sendHtmlEmail(emailAddress, `Reset Password for ${config.appName}`, htmlEmailBody);
     }
     async resetPassword(email, passwordResetToken, password) {
-        const retrievedPasswordResetToken = await this.passwordResetTokenService.getByEmail(email);
+        const lowerCaseEmail = email.toLowerCase();
+        const retrievedPasswordResetToken = await this.passwordResetTokenService.getByEmail(lowerCaseEmail);
         if (!retrievedPasswordResetToken) {
-            throw new ServerError(`Unable to retrieve password reset token for email: ${email}`);
+            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 result = await this.changePassword(EmptyUserContext, { email }, password);
-        console.log(`password changed using forgot-password for email: ${email}`);
+        const result = await this.changePassword(EmptyUserContext, { email: lowerCaseEmail }, password);
+        console.log(`password changed using forgot-password for email: ${lowerCaseEmail}`);
         await this.passwordResetTokenService.deleteById(EmptyUserContext, retrievedPasswordResetToken._id.toString());
-        console.log(`passwordResetToken deleted for email: ${email}`);
+        console.log(`passwordResetToken deleted for email: ${lowerCaseEmail}`);
         return result;
     }
     deleteRefreshTokensForDevice(deviceId) {

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

@@ -2,7 +2,7 @@ import { Db } from 'mongodb';
 import { IUserContext, IEntity, QueryOptions, IModelSpec } from '@loomcore/common/models';
 import { GenericApiService } from './generic-api.service.js';
 export declare class MultiTenantApiService<T extends IEntity> extends GenericApiService<T> {
-    private tenantDecorator;
+    private tenantDecorator?;
     constructor(db: Db, pluralResourceName: string, singularResourceName: string, modelSpec?: IModelSpec);
     protected prepareQuery(userContext: IUserContext, query: any): any;
     protected prepareQueryOptions(userContext: IUserContext, queryOptions: QueryOptions): QueryOptions;

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

@@ -1,25 +1,37 @@
 import { GenericApiService } from './generic-api.service.js';
 import { TenantQueryDecorator } from './tenant-query-decorator.js';
 import { BadRequestError } from '../errors/bad-request.error.js';
+import { config } from '../config/base-api-config.js';
 export class MultiTenantApiService extends GenericApiService {
     tenantDecorator;
     constructor(db, pluralResourceName, singularResourceName, modelSpec) {
         super(db, pluralResourceName, singularResourceName, modelSpec);
-        this.tenantDecorator = new TenantQueryDecorator();
+        if (config?.app?.isMultiTenant) {
+            this.tenantDecorator = new TenantQueryDecorator();
+        }
     }
     prepareQuery(userContext, query) {
+        if (!config?.app?.isMultiTenant) {
+            return super.prepareQuery(userContext, query);
+        }
         if (!userContext || !userContext._orgId) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQuery');
         }
         return this.tenantDecorator.applyTenantToQuery(userContext, query, this.pluralResourceName);
     }
     prepareQueryOptions(userContext, queryOptions) {
+        if (!config?.app?.isMultiTenant) {
+            return super.prepareQueryOptions(userContext, queryOptions);
+        }
         if (!userContext || !userContext._orgId) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQueryOptions');
         }
         return this.tenantDecorator.applyTenantToQueryOptions(userContext, queryOptions, this.pluralResourceName);
     }
     async prepareEntity(userContext, entity, isCreate) {
+        if (!config?.app?.isMultiTenant) {
+            return super.prepareEntity(userContext, entity, isCreate);
+        }
         if (!userContext || !userContext._orgId) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
         }

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

@@ -6,15 +6,16 @@ export class PasswordResetTokenService extends GenericApiService {
         super(db, 'passwordResetTokens', 'passwordResetToken', PasswordResetTokenSpec);
     }
     async createPasswordResetToken(email, expiresOn) {
-        await this.collection.deleteMany({ email });
+        const lowerCaseEmail = email.toLowerCase();
+        await this.collection.deleteMany({ email: lowerCaseEmail });
         const passwordResetToken = {
-            email,
+            email: lowerCaseEmail,
             token: crypto.randomBytes(40).toString('hex'),
             expiresOn: expiresOn,
         };
         return super.create(EmptyUserContext, passwordResetToken);
     }
     async getByEmail(email) {
-        return await super.findOne(EmptyUserContext, { email });
+        return await super.findOne(EmptyUserContext, { email: email.toLowerCase() });
     }
 }

package/dist/services/user.service.js

@@ -11,6 +11,9 @@ export class UserService extends MultiTenantApiService {
     }
     async prepareEntity(userContext, entity, isCreate) {
         const preparedEntity = await super.prepareEntity(userContext, entity, isCreate);
+        if (preparedEntity.email) {
+            preparedEntity.email = preparedEntity.email.toLowerCase();
+        }
         if (!isCreate) {
             return Value.Clean(PublicUserSchema, preparedEntity);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.13",
+  "version": "0.0.16",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -44,7 +44,7 @@
     "jsonwebtoken": "^9.0.2"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.7",
+    "@loomcore/common": "^0.0.8",
     "@sinclair/typebox": "^0.34.31",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",