@loomcore/api 0.1.19 → 0.1.21

package/dist/controllers/auth.controller.js

@@ -31,11 +31,20 @@ export class AuthController {
         const body = req.body;
         const validationErrors = this.authService.validate(body);
         entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
+        if (!userContext) {
+            throw new BadRequestError('Missing required fields: userContext is required.');
+        }
         const user = await this.authService.createUser(userContext, body);
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
     }
     async requestTokenUsingRefreshToken(req, res, next) {
-        let tokens = await this.authService.requestTokenUsingRefreshToken(req);
+        const userContext = req.userContext;
+        const refreshToken = req.query.refreshToken;
+        if (!userContext || !refreshToken || typeof refreshToken !== 'string') {
+            throw new BadRequestError('Missing required fields: userContext and refreshToken are required.');
+        }
+        const deviceId = this.authService.getDeviceIdFromCookie(req);
+        const tokens = await this.authService.requestTokenUsingRefreshToken(userContext, refreshToken, deviceId);
         if (tokens) {
             apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
         }

package/dist/databases/postgres/migrations/006-create-admin-user.migration.d.ts

@@ -4,9 +4,10 @@ export declare class CreateAdminUserMigration implements IMigration {
     private readonly client;
     private readonly adminEmail;
     private readonly adminPassword;
-    constructor(client: Client, adminEmail: string, adminPassword: string);
+    private readonly _orgId?;
+    constructor(client: Client, adminEmail: string, adminPassword: string, _orgId?: string | undefined);
     index: number;
-    execute(_orgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
         error: Error;
     } | {

package/dist/databases/postgres/migrations/006-create-admin-user.migration.js

@@ -6,20 +6,22 @@ export class CreateAdminUserMigration {
     client;
     adminEmail;
     adminPassword;
-    constructor(client, adminEmail, adminPassword) {
+    _orgId;
+    constructor(client, adminEmail, adminPassword, _orgId) {
         this.client = client;
         this.adminEmail = adminEmail;
         this.adminPassword = adminPassword;
+        this._orgId = _orgId;
     }
     index = 6;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             const database = new PostgresDatabase(this.client);
             const authService = new AuthService(database);
             const adminUser = await authService.createUser(getSystemUserContext(), {
                 _id: _id,
-                _orgId: _orgId,
+                _orgId: this._orgId,
                 email: this.adminEmail,
                 password: this.adminPassword,
                 firstName: 'Admin',

package/dist/databases/postgres/migrations/setup-for-auth.migration.js

@@ -3,6 +3,7 @@ import { CreateMigrationTableMigration } from "./001-create-migrations-table.mig
 import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
 import { CreateAdminUserMigration } from "./006-create-admin-user.migration.js";
+import { getSystemUserContext } from "@loomcore/common/models";
 export async function setupDatabaseForAuth(client, adminUsername, adminPassword) {
     let runMigrations = [];
     if (await doesTableExist(client, 'migrations')) {
@@ -22,8 +23,10 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword)
         migrationsToRun.push(new CreateUsersTableMigration(client));
     if (!runMigrations.includes(4))
         migrationsToRun.push(new CreateRefreshTokenTableMigration(client));
-    if (!runMigrations.includes(6))
-        migrationsToRun.push(new CreateAdminUserMigration(client, adminUsername, adminPassword));
+    if (!runMigrations.includes(6)) {
+        const systemUserContext = getSystemUserContext();
+        migrationsToRun.push(new CreateAdminUserMigration(client, adminUsername, adminPassword, systemUserContext._orgId));
+    }
     for (const migration of migrationsToRun) {
         await migration.execute();
     }

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

@@ -1,13 +1,14 @@
 import { Request, Response } from 'express';
 import { IUserContext, IUser, ITokenResponse, ILoginResponse } from '@loomcore/common/models';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
+import { MultiTenantApiService } from './multi-tenant-api.service.js';
 import { UpdateResult } from '../databases/models/update-result.js';
 import { IRefreshToken } from '../models/refresh-token.model.js';
 import { IDatabase } from '../databases/models/index.js';
-export declare class AuthService extends GenericApiService<IUser> {
+export declare class AuthService extends MultiTenantApiService<IUser> {
     private refreshTokenService;
     private passwordResetTokenService;
     private emailService;
+    private organizationService;
     constructor(database: IDatabase);
     attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
     logUserIn(userContext: IUserContext, deviceId: string): Promise<{
@@ -18,23 +19,22 @@ export declare class AuthService extends GenericApiService<IUser> {
         };
         userContext: IUserContext;
     } | null>;
-    getUserById(id: string): Promise<IUser | null>;
     getUserByEmail(email: string): Promise<IUser | null>;
     createUser(userContext: IUserContext, user: Partial<IUser>): Promise<IUser | null>;
-    requestTokenUsingRefreshToken(req: Request): Promise<ITokenResponse | null>;
+    requestTokenUsingRefreshToken(userContext: IUserContext, refreshToken: string, deviceId: string): Promise<ITokenResponse | null>;
     changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult>;
     changePassword(userContext: IUserContext, queryObject: any, password: string): Promise<UpdateResult>;
-    createNewTokens(userId: string, deviceId: string, refreshTokenExpiresOn: number): Promise<{
+    createNewTokens(userContext: IUserContext, activeRefreshToken: IRefreshToken): Promise<{
         accessToken: string;
-        refreshToken: any;
+        refreshToken: string;
         expiresOn: number;
-    } | null>;
+    }>;
     getActiveRefreshToken(userContext: IUserContext, refreshToken: string, deviceId: string): Promise<IRefreshToken | null>;
     createNewRefreshToken(userId: string, deviceId: string, existingExpiresOn?: number | null, orgId?: string): Promise<IRefreshToken | null>;
     sendResetPasswordEmail(emailAddress: string): Promise<void>;
     resetPassword(email: string, passwordResetToken: string, password: string): Promise<UpdateResult>;
     deleteRefreshTokensForDevice(deviceId: string): Promise<import("../databases/models/delete-result.js").DeleteResult>;
-    generateJwt(payload: any): string;
+    generateJwt(userContext: IUserContext): string;
     generateRefreshToken(): string;
     generateDeviceId(): string;
     getAndSetDeviceIdCookie(req: Request, res: Response): string;

package/dist/services/auth.service.js

@@ -5,19 +5,23 @@ 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';
-export class AuthService extends GenericApiService {
+export class AuthService extends MultiTenantApiService {
     refreshTokenService;
     passwordResetTokenService;
     emailService;
+    organizationService;
     constructor(database) {
         super(database, 'users', 'user', UserSpec);
         this.refreshTokenService = new GenericApiService(database, 'refreshTokens', 'refreshToken', refreshTokenModelSpec);
         this.passwordResetTokenService = new PasswordResetTokenService(database);
         this.emailService = new EmailService();
+        this.organizationService = new OrganizationService(database);
     }
     async attemptLogin(req, res, email, password) {
         const lowerCaseEmail = email.toLowerCase();
@@ -56,31 +60,39 @@ export class AuthService extends GenericApiService {
         }
         return loginResponse;
     }
-    async getUserById(id) {
-        const user = await this.findOne(EmptyUserContext, { filters: { _id: { eq: id } } });
-        return user;
-    }
     async getUserByEmail(email) {
-        const user = await this.findOne(EmptyUserContext, { filters: { email: { eq: email.toLowerCase() } } });
-        return user;
+        const queryOptions = { filters: { email: { eq: email.toLowerCase() } } };
+        const rawUser = await this.database.findOne(queryOptions, 'users');
+        if (!rawUser) {
+            return null;
+        }
+        const userContext = {
+            _orgId: rawUser._orgId,
+            user: rawUser
+        };
+        return this.postprocessEntity(userContext, rawUser);
     }
     async createUser(userContext, user) {
+        if (user.email) {
+            const existingUser = await this.getUserByEmail(user.email);
+            if (existingUser) {
+                throw new BadRequestError('A user with this email address already exists');
+            }
+        }
+        if (user._orgId && userContext._orgId && userContext._orgId !== user._orgId && userContext.user?._id !== 'system') {
+            const org = await this.organizationService.findOne(userContext, { filters: { _id: { eq: user._orgId } } });
+            if (!org) {
+                throw new BadRequestError('The specified organization does not exist');
+            }
+        }
         const createdUser = await this.create(userContext, user);
         return createdUser;
     }
-    async requestTokenUsingRefreshToken(req) {
-        const refreshToken = req.query.refreshToken;
-        const deviceId = this.getDeviceIdFromCookie(req);
+    async requestTokenUsingRefreshToken(userContext, refreshToken, deviceId) {
         let tokens = null;
-        if (refreshToken && typeof refreshToken === 'string' && deviceId && typeof deviceId === 'string') {
-            let userId = null;
-            const activeRefreshToken = await this.getActiveRefreshToken(EmptyUserContext, refreshToken, deviceId);
-            if (activeRefreshToken) {
-                userId = activeRefreshToken.userId;
-                if (userId) {
-                    tokens = await this.createNewTokens(userId, deviceId, activeRefreshToken.expiresOn);
-                }
-            }
+        const activeRefreshToken = await this.getActiveRefreshToken(userContext, refreshToken, deviceId);
+        if (activeRefreshToken) {
+            tokens = await this.createNewTokens(userContext, activeRefreshToken);
         }
         return tokens;
     }
@@ -98,27 +110,15 @@ export class AuthService extends GenericApiService {
         };
         return result;
     }
-    async createNewTokens(userId, deviceId, refreshTokenExpiresOn) {
-        let createdRefreshTokenObject = null;
-        const user = await this.getUserById(userId);
-        const newRefreshToken = await this.createNewRefreshToken(userId, deviceId, refreshTokenExpiresOn, user?._orgId);
-        if (newRefreshToken) {
-            createdRefreshTokenObject = newRefreshToken;
-        }
-        let tokenResponse = null;
-        if (user && createdRefreshTokenObject) {
-            const payload = {
-                user: user,
-                _orgId: user._orgId
-            };
-            const accessToken = this.generateJwt(payload);
-            const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
-            tokenResponse = {
-                accessToken,
-                refreshToken: createdRefreshTokenObject.token,
-                expiresOn: accessTokenExpiresOn
-            };
-        }
+    async createNewTokens(userContext, activeRefreshToken) {
+        const payload = userContext;
+        const accessToken = this.generateJwt(payload);
+        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
+        const tokenResponse = {
+            accessToken,
+            refreshToken: activeRefreshToken.token,
+            expiresOn: accessTokenExpiresOn
+        };
         return tokenResponse;
     }
     async getActiveRefreshToken(userContext, refreshToken, deviceId) {
@@ -181,13 +181,10 @@ export class AuthService extends GenericApiService {
     deleteRefreshTokensForDevice(deviceId) {
         return this.refreshTokenService.deleteMany(EmptyUserContext, { filters: { deviceId: { eq: deviceId } } });
     }
-    generateJwt(payload) {
-        if (payload._orgId !== undefined) {
-            payload._orgId = String(payload._orgId);
-        }
+    generateJwt(userContext) {
         const jwtExpiryConfig = config.auth.jwtExpirationInSeconds;
         const jwtExpirationInSeconds = (typeof jwtExpiryConfig === 'string') ? parseInt(jwtExpiryConfig) : jwtExpiryConfig;
-        const accessToken = JwtService.sign(payload, config.clientSecret, {
+        const accessToken = JwtService.sign(userContext, config.clientSecret, {
             expiresIn: jwtExpirationInSeconds
         });
         return accessToken;

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

@@ -28,8 +28,9 @@ export class MultiTenantApiService extends GenericApiService {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
         }
         const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
-        const orgIdField = this.tenantDecorator.getOrgIdField();
-        preparedEntity[orgIdField] = userContext._orgId;
+        if (isCreate && userContext.user._id !== 'system') {
+            preparedEntity._orgId = userContext._orgId;
+        }
         return preparedEntity;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {