@loomcore/api 0.1.57 → 0.1.58

package/dist/__tests__/common-test.utils.d.ts

@@ -7,6 +7,7 @@ import { GenericApiService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
 import { ICategory } from './models/category.model.js';
 import { IProduct } from './models/product.model.js';
+import { DbType } from '../databases/db-type.type.js';
 declare function initialize(database: IDatabase): void;
 declare function getRandomId(): string;
 declare function isMongoDatabase(database: IDatabase): boolean;
@@ -28,7 +29,7 @@ export declare class CategoryService extends GenericApiService<ICategory> {
 export declare class CategoryController extends ApiController<ICategory> {
     constructor(app: Application, database: IDatabase);
 }
-export declare function setupTestConfig(isMultiTenant?: boolean): void;
+export declare function setupTestConfig(isMultiTenant: boolean | undefined, dbType: DbType): void;
 export declare class ProductService extends GenericApiService<IProduct> {
     private db;
     constructor(database: IDatabase);

package/dist/__tests__/common-test.utils.js

@@ -174,47 +174,47 @@ export class CategoryController extends ApiController {
         super('categories', app, categoryService, 'category', CategorySpec);
     }
 }
-export function setupTestConfig(isMultiTenant = true) {
+export function setupTestConfig(isMultiTenant = true, dbType) {
     setBaseApiConfig({
-        env: 'test',
-        hostName: 'localhost',
-        appName: 'test-app',
-        clientSecret: 'test-secret',
-        database: {
-            name: 'test-db',
-        },
-        externalPort: 4000,
-        internalPort: 8083,
-        corsAllowedOrigins: ['*'],
-        saltWorkFactor: 10,
-        jobTypes: '',
-        deployedBranch: '',
-        debug: {
-            showErrors: false
-        },
         app: {
-            isMultiTenant: isMultiTenant,
+            isMultiTenant: isMultiTenant, name: 'test-app', dbType: dbType,
             ...(isMultiTenant && {
                 metaOrgName: 'Test Meta Organization',
                 metaOrgCode: 'TEST_META_ORG'
             })
         },
         auth: {
+            adminUser: {
+                email: 'admin@test.com',
+                password: 'admin-password'
+            },
+            clientSecret: 'test-secret',
+            saltWorkFactor: 10,
             jwtExpirationInSeconds: 3600,
             refreshTokenExpirationInDays: 7,
             deviceIdCookieMaxAgeInDays: 730,
             passwordResetTokenExpirationInMinutes: 20
         },
+        database: {
+            name: 'test-db',
+            host: 'localhost',
+            password: 'test-password',
+            port: 27017,
+            username: 'test-user'
+        },
+        env: 'test',
         email: {
             emailApiKey: 'WeDontHaveAKeyYet',
             emailApiSecret: 'WeDontHaveASecretYet',
             fromAddress: 'test@test.com',
             systemEmailAddress: 'system@test.com'
         },
-        adminUser: {
-            email: 'admin@test.com',
-            password: 'admin-password'
-        }
+        network: {
+            hostName: 'localhost',
+            internalPort: 8083,
+            externalPort: 4000,
+            corsAllowedOrigins: ['*']
+        },
     });
 }
 export class ProductService extends GenericApiService {

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

@@ -26,7 +26,7 @@ export class TestExpressApp {
         return this.initPromise;
     }
     static async _performInit(useMongoDb) {
-        setupTestConfig();
+        setupTestConfig(true, useMongoDb ? 'mongodb' : 'postgres');
         initializeTypeBox();
         if (!this.database) {
             if (useMongoDb) {

package/dist/databases/migrations/migration-runner.js

@@ -1,6 +1,7 @@
 import { Umzug, MongoDBStorage } from 'umzug';
 import { Pool } from 'pg';
 import { MongoClient } from 'mongodb';
+import { setBaseApiConfig } from '../../config/index.js';
 import fs from 'fs';
 import path from 'path';
 import { buildMongoUrl } from '../mongo-db/utils/build-mongo-url.util.js';
@@ -15,6 +16,7 @@ export class MigrationRunner {
     primaryTimezone;
     dbConnection;
     constructor(config) {
+        setBaseApiConfig(config);
         this.config = config;
         this.dbType = config.app.dbType || 'mongodb';
         this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -146,11 +146,11 @@ export const getMongoInitialSchema = (config) => {
             }
         });
     }
-    if (config.adminUser?.email && config.adminUser?.password) {
+    if (config.auth && config.auth.adminUser) {
         migrations.push({
             name: '00000000000009_data-admin-user',
             up: async ({ context: db }) => {
-                if (!config.adminUser?.email || !config.adminUser?.password) {
+                if (config.auth?.adminUser?.email || !config.auth?.adminUser?.password) {
                     throw new Error('Admin user email and password must be provided in config');
                 }
                 const database = new MongoDBDatabase(db);
@@ -160,25 +160,25 @@ export const getMongoInitialSchema = (config) => {
                 await authService.createUser(systemUserContext, {
                     _id: _id,
                     _orgId: systemUserContext.organization?._id,
-                    email: config.adminUser.email,
-                    password: config.adminUser.password,
+                    email: config.auth?.adminUser?.email,
+                    password: config.auth?.adminUser?.password,
                     firstName: 'Admin',
                     lastName: 'User',
                     displayName: 'Admin User',
                 });
             },
             down: async ({ context: db }) => {
-                if (!config.adminUser?.email)
+                if (!config.auth?.adminUser?.email)
                     return;
-                await db.collection('users').deleteOne({ email: config.adminUser.email });
+                await db.collection('users').deleteOne({ email: config.auth?.adminUser?.email });
             }
         });
     }
-    if (config.adminUser?.email && isMultiTenant) {
+    if (config.auth?.adminUser?.email && isMultiTenant) {
         migrations.push({
             name: '00000000000010_data-admin-authorizations',
             up: async ({ context: db }) => {
-                if (!config.adminUser?.email) {
+                if (!config.auth?.adminUser?.email) {
                     throw new Error('Admin user email not found in config');
                 }
                 const database = new MongoDBDatabase(db);
@@ -188,7 +188,7 @@ export const getMongoInitialSchema = (config) => {
                 if (!metaOrg) {
                     throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                 }
-                const adminUser = await authService.getUserByEmail(config.adminUser.email);
+                const adminUser = await authService.getUserByEmail(config.auth?.adminUser?.email);
                 if (!adminUser) {
                     throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                 }

package/dist/databases/mongo-db/utils/build-mongo-url.util.js

@@ -3,11 +3,11 @@ export function buildMongoUrl(config) {
     if (!database) {
         throw new Error("Database configuration is required to build the MongoDB URL.");
     }
-    const { user, password, host, port, name } = database;
-    if (!user || !password || !host || !port || !name) {
+    const { username, password, host, port, name } = database;
+    if (!username || !password || !host || !port || !name) {
         throw new Error("Database configuration must include user, password, host, port, and name to build the MongoDB URL.");
     }
-    const encodedUser = encodeURIComponent(user);
+    const encodedUsername = encodeURIComponent(username);
     const encodedPassword = encodeURIComponent(password);
-    return `mongodb://${encodedUser}:${encodedPassword}@${host}:${port}/${name}`;
+    return `mongodb://${encodedUsername}:${encodedPassword}@${host}:${port}/${name}`;
 }

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -207,11 +207,11 @@ export const getPostgresInitialSchema = (config) => {
             }
         });
     }
-    if (config.adminUser?.email && config.adminUser?.password) {
+    if (config.auth?.adminUser?.email && config.auth?.adminUser?.password) {
         migrations.push({
             name: '00000000000009_data-admin-user',
             up: async ({ context: pool }) => {
-                if (!config.adminUser?.email || !config.adminUser?.password) {
+                if (!config.auth?.adminUser?.email || !config.auth?.adminUser?.password) {
                     throw new Error('Admin user email and password must be provided in config');
                 }
                 const client = await pool.connect();
@@ -236,8 +236,8 @@ export const getPostgresInitialSchema = (config) => {
                         }
                     }
                     const userData = {
-                        email: config.adminUser.email,
-                        password: config.adminUser.password,
+                        email: config.auth?.adminUser?.email,
+                        password: config.auth?.adminUser?.password,
                         firstName: 'Admin',
                         lastName: 'User',
                         displayName: 'Admin User',
@@ -252,17 +252,17 @@ export const getPostgresInitialSchema = (config) => {
                 }
             },
             down: async ({ context: pool }) => {
-                if (!config.adminUser?.email)
+                if (!config.auth?.adminUser?.email)
                     return;
-                const result = await pool.query(`DELETE FROM "users" WHERE "email" = $1`, [config.adminUser.email]);
+                const result = await pool.query(`DELETE FROM "users" WHERE "email" = $1`, [config.auth?.adminUser?.email]);
             }
         });
     }
-    if (config.adminUser?.email) {
+    if (config.auth?.adminUser?.email) {
         migrations.push({
             name: '00000000000010_data-admin-authorizations',
             up: async ({ context: pool }) => {
-                if (!config.adminUser?.email) {
+                if (!config.auth?.adminUser?.email) {
                     throw new Error('Admin user email not found in config');
                 }
                 const client = await pool.connect();
@@ -274,7 +274,7 @@ export const getPostgresInitialSchema = (config) => {
                     if (isMultiTenant && !metaOrg) {
                         throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                     }
-                    const adminUser = await authService.getUserByEmail(config.adminUser.email);
+                    const adminUser = await authService.getUserByEmail(config.auth?.adminUser?.email);
                     if (!adminUser) {
                         throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                     }

package/dist/databases/postgres/utils/build-postgres-url.util.js

@@ -3,11 +3,11 @@ export function buildPostgresUrl(config) {
     if (!database) {
         throw new Error("Database configuration is required to build the PostgreSQL URL.");
     }
-    const { user, password, host, port, name } = database;
-    if (!user || !password || !host || !port || !name) {
+    const { username, password, host, port, name } = database;
+    if (!username || !password || !host || !port || !name) {
         throw new Error("Database configuration must include user, password, host, port, and name to build the PostgreSQL URL.");
     }
-    const encodedUser = encodeURIComponent(user);
+    const encodedUsername = encodeURIComponent(username);
     const encodedPassword = encodeURIComponent(password);
-    return `postgresql://${encodedUser}:${encodedPassword}@${host}:${port}/${name}`;
+    return `postgresql://${encodedUsername}:${encodedPassword}@${host}:${port}/${name}`;
 }

package/dist/middleware/is-authorized.js

@@ -16,7 +16,7 @@ const isAuthorized = (allowedFeatures) => {
             throw new UnauthenticatedError();
         }
         try {
-            const rawPayload = JwtService.verify(token, config.clientSecret);
+            const rawPayload = JwtService.verify(token, config.auth?.clientSecret || '');
             const userContext = UserContextSpec.decode(rawPayload);
             req.userContext = userContext;
             if (userContext.authorizations.some(authorization => authorization.feature === 'admin')) {

package/dist/models/auth-config.interface.d.ts

@@ -0,0 +1,12 @@
+export interface IAuthConfig {
+    adminUser: {
+        email: string;
+        password: string;
+    };
+    clientSecret: string;
+    saltWorkFactor: number;
+    deviceIdCookieMaxAgeInDays: number;
+    jwtExpirationInSeconds: number;
+    passwordResetTokenExpirationInMinutes: number;
+    refreshTokenExpirationInDays: number;
+}

package/dist/models/auth-config.interface.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,41 +1,24 @@
 import { DbType } from "../databases/db-type.type.js";
+import { IAuthConfig } from "./auth-config.interface.js";
 export interface IBaseApiConfig {
-    appName: string;
-    env: string;
-    hostName: string;
-    clientSecret: string;
-    database: {
-        name?: string;
-        host?: string;
-        port?: number;
-        user?: string;
-        password?: string;
-    };
-    externalPort?: number;
-    internalPort?: number;
-    corsAllowedOrigins: string[];
-    saltWorkFactor?: number;
-    jobTypes?: string;
-    deployedBranch?: string;
-    debug?: {
-        showErrors?: boolean;
-    };
     app: {
+        dbType?: DbType;
         isMultiTenant: boolean;
-        metaOrgName?: string;
         metaOrgCode?: string;
-        dbType?: DbType;
+        metaOrgName?: string;
+        name: string;
         primaryTimezone?: string;
     };
-    adminUser?: {
-        email: string;
+    auth?: IAuthConfig;
+    database?: {
+        host: string;
+        name: string;
         password: string;
+        port: number;
+        username: string;
     };
-    auth: {
-        jwtExpirationInSeconds: number;
-        refreshTokenExpirationInDays: number;
-        deviceIdCookieMaxAgeInDays: number;
-        passwordResetTokenExpirationInMinutes: number;
+    debug?: {
+        showErrors?: boolean;
     };
     email?: {
         emailApiKey: string;
@@ -43,4 +26,11 @@ export interface IBaseApiConfig {
         fromAddress: string;
         systemEmailAddress: string;
     };
+    env: string;
+    network: {
+        corsAllowedOrigins: string[];
+        externalPort?: number;
+        hostName: string;
+        internalPort?: number;
+    };
 }

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

@@ -10,6 +10,7 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
     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<{

package/dist/services/auth.service.js

@@ -17,12 +17,17 @@ export class AuthService extends MultiTenantApiService {
     passwordResetTokenService;
     emailService;
     organizationService;
+    authConfig;
     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);
+        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();
@@ -49,7 +54,7 @@ export class AuthService extends MultiTenantApiService {
         const payload = userContext;
         const accessToken = this.generateJwt(payload);
         const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id, deviceId, userContext.organization?._id);
-        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
+        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(this.authConfig.jwtExpirationInSeconds);
         let loginResponse = null;
         if (refreshTokenObject) {
             const tokenResponse = {
@@ -126,7 +131,7 @@ export class AuthService extends MultiTenantApiService {
     async createNewTokens(userContext, activeRefreshToken) {
         const payload = userContext;
         const accessToken = this.generateJwt(payload);
-        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
+        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(this.authConfig.jwtExpirationInSeconds);
         const tokenResponse = {
             accessToken,
             refreshToken: activeRefreshToken.token,
@@ -147,7 +152,7 @@ export class AuthService extends MultiTenantApiService {
         return activeRefreshToken;
     }
     async createNewRefreshToken(userId, deviceId, orgId) {
-        const expiresOn = this.getExpiresOnFromDays(config.auth.refreshTokenExpirationInDays);
+        const expiresOn = this.getExpiresOnFromDays(this.authConfig.refreshTokenExpirationInDays);
         const newRefreshToken = {
             _orgId: orgId,
             token: this.generateRefreshToken(),
@@ -162,17 +167,16 @@ export class AuthService extends MultiTenantApiService {
         return insertResult;
     }
     async sendResetPasswordEmail(emailAddress) {
-        const expiresOn = this.getExpiresOnFromMinutes(config.auth.passwordResetTokenExpirationInMinutes);
+        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 httpOrHttps = config.env === 'local' ? 'http' : 'https';
         const urlEncodedEmail = encodeURIComponent(emailAddress);
-        const clientUrl = config.hostName;
-        const resetPasswordLink = `${httpOrHttps}://${clientUrl}/reset-password/${passwordResetToken.token}/${urlEncodedEmail}`;
+        const resetPasswordLink = `${httpOrHttps}://${config.network.hostName}/reset-password/${passwordResetToken.token}/${urlEncodedEmail}`;
         const htmlEmailBody = `<strong><a href="${resetPasswordLink}">Reset Password</a></strong>`;
-        await this.emailService.sendHtmlEmail(emailAddress, `Reset Password for ${config.appName}`, htmlEmailBody);
+        await this.emailService.sendHtmlEmail(emailAddress, `Reset Password for ${config.app.name}`, htmlEmailBody);
     }
     async resetPassword(email, passwordResetToken, password) {
         const lowerCaseEmail = email.toLowerCase();
@@ -195,9 +199,9 @@ export class AuthService extends MultiTenantApiService {
         return this.refreshTokenService.deleteMany(EmptyUserContext, { filters: { deviceId: { eq: deviceId } } });
     }
     generateJwt(userContext) {
-        const jwtExpiryConfig = config.auth.jwtExpirationInSeconds;
+        const jwtExpiryConfig = this.authConfig.jwtExpirationInSeconds;
         const jwtExpirationInSeconds = (typeof jwtExpiryConfig === 'string') ? parseInt(jwtExpiryConfig) : jwtExpiryConfig;
-        const accessToken = JwtService.sign(userContext, config.clientSecret, {
+        const accessToken = JwtService.sign(userContext, this.authConfig.clientSecret, {
             expiresIn: jwtExpirationInSeconds
         });
         return accessToken;
@@ -222,7 +226,7 @@ export class AuthService extends MultiTenantApiService {
         }
         if (isNewDeviceId) {
             const cookieOptions = {
-                maxAge: config.auth.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
+                maxAge: this.authConfig.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
                 httpOnly: true
             };
             res.cookie('deviceId', deviceId, cookieOptions);

package/dist/services/email.service.js

@@ -2,23 +2,28 @@ import * as Mailjet from 'node-mailjet';
 import { ServerError } from '../errors/index.js';
 import { config } from '../config/index.js';
 export class EmailService {
-    mailjet;
+    mailjet = null;
     constructor() {
-        this.mailjet = new Mailjet.default({
-            apiKey: config.email?.emailApiKey || '',
-            apiSecret: config.email?.emailApiSecret || ''
-        });
+        if (config && config.email?.emailApiKey && config.email?.emailApiSecret) {
+            this.mailjet = new Mailjet.default({
+                apiKey: config.email.emailApiKey,
+                apiSecret: config.email.emailApiSecret
+            });
+        }
     }
     async sendHtmlEmail(emailAddress, subject, body) {
-        if (!config.email?.fromAddress) {
-            throw new ServerError('From address is not set in the config');
+        if (!config || !config.email?.fromAddress) {
+            throw new ServerError('Email configuration is not available. From address is not set in the config.');
+        }
+        if (!this.mailjet) {
+            throw new ServerError('Email service is not configured. Email API credentials are not set in the config.');
         }
         const messageData = {
             Messages: [
                 {
                     From: {
                         Email: config.email?.fromAddress,
-                        Name: config.appName || 'Application'
+                        Name: config.app.name || 'Application'
                     },
                     To: [
                         {

package/dist/utils/express.utils.js

@@ -20,7 +20,7 @@ function setupExpressApp(database, config, setupRoutes) {
     app.use(bodyParser.json());
     app.use(cookieParser());
     app.use(cors({
-        origin: config.corsAllowedOrigins,
+        origin: config.network.corsAllowedOrigins,
         credentials: true
     }));
     app.use(ensureUserContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "jsonwebtoken": "^9.0.2",
     "node-mailjet": "^6.0.8",
-    "qs": "^6.14.0"
+    "qs": "^6.14.1"
   },
   "peerDependencies": {
     "@loomcore/common": "^0.0.43",