fix(models): move User to DBUser

packages/server/lib/controllers/config.controller.integration.test.ts

@@ -1,17 +1,16 @@
 import { expect, describe, it, vi, beforeAll } from 'vitest';
 import type { Request, NextFunction } from 'express';
-import type { User } from '@nangohq/shared';
 import { NangoError } from '@nangohq/shared';
 import db, { multipleMigrations } from '@nangohq/database';
 import configController from './config.controller';
 import type { RequestLocals } from '../utils/express.js';
-import type { DBTeam, DBEnvironment, ConnectSession } from '@nangohq/types';
+import type { DBTeam, DBEnvironment, ConnectSession, DBUser } from '@nangohq/types';
 
 const locals: Required<RequestLocals> = {
     authType: 'secretKey',
     account: { id: 0 } as DBTeam,
     environment: { id: 1 } as DBEnvironment,
-    user: { id: 0 } as User,
+    user: { id: 0 } as DBUser,
     connectSession: { id: 0 } as ConnectSession
 };
 /**

packages/server/lib/helpers/email.ts

@@ -1,7 +1,6 @@
 import { basePublicUrl } from '@nangohq/utils';
 import { EmailClient } from '../clients/email.client.js';
-import type { User } from '@nangohq/shared';
-import type { DBInvitation, DBTeam } from '@nangohq/types';
+import type { DBInvitation, DBTeam, DBUser } from '@nangohq/types';
 
 export function sendVerificationEmail(email: string, name: string, token: string) {
     const emailClient = EmailClient.getInstance();
@@ -21,7 +20,7 @@ Team Nango</p>
     );
 }
 
-export async function sendResetPasswordEmail({ user, token }: { user: User; token: string }) {
+export async function sendResetPasswordEmail({ user, token }: { user: DBUser; token: string }) {
     const emailClient = EmailClient.getInstance();
     await emailClient.send(
         user.email,
@@ -46,13 +45,13 @@ export async function sendInviteEmail({
 }: {
     email: string;
     account: DBTeam;
-    user: Pick<User, 'name'>;
+    user: Pick<DBUser, 'name'>;
     invitation: DBInvitation;
 }) {
     const emailClient = EmailClient.getInstance();
     await emailClient.send(
         email,
-        `You’re Invited! Join "${account.name}" on Nango`,
+        `You're Invited! Join "${account.name}" on Nango`,
         `<p>Hi,</p>
 
 <p>${user.name} invites you to join "${account.name}" on Nango.</p>

packages/server/lib/utils/express.ts

@@ -1,9 +1,8 @@
-import type { User } from '@nangohq/shared';
-import type { DBEnvironment, DBTeam, ConnectSession } from '@nangohq/types';
+import type { DBEnvironment, DBTeam, ConnectSession, DBUser } from '@nangohq/types';
 
 export interface RequestLocals {
     authType?: 'secretKey' | 'publicKey' | 'basic' | 'adminKey' | 'none' | 'session' | 'connectSession';
-    user?: Pick<User, 'id' | 'email' | 'name'>;
+    user?: Pick<DBUser, 'id' | 'email' | 'name'>;
     account?: DBTeam;
     environment?: DBEnvironment;
     connectSession?: ConnectSession;

packages/server/lib/utils/utils.ts

@@ -1,8 +1,7 @@
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import type { Request } from 'express';
-import type { User } from '@nangohq/shared';
-import type { Provider, ProviderTwoStep } from '@nangohq/types';
+import type { DBUser, Provider, ProviderTwoStep } from '@nangohq/types';
 import type { Result } from '@nangohq/utils';
 import { getLogger, Err, Ok } from '@nangohq/utils';
 import type { WSErr } from './web-socket-error.js';
@@ -11,7 +10,7 @@ import { OrchestratorClient } from '@nangohq/nango-orchestrator';
 
 const logger = getLogger('Server.Utils');
 
-export async function getUserFromSession(req: Request<any>): Promise<Result<User, NangoError>> {
+export async function getUserFromSession(req: Request<any>): Promise<Result<DBUser, NangoError>> {
     const sessionUser = req.user;
     if (!sessionUser) {
         const error = new NangoError('user_not_found');
@@ -20,7 +19,6 @@ export async function getUserFromSession(req: Request<any>): Promise<Result<User
     }
 
     const user = await userService.getUserById(sessionUser.id);
-
     if (!user) {
         const error = new NangoError('user_not_found');
         return Err(error);

packages/shared/lib/models/index.ts

@@ -1,5 +1,4 @@
 export * from './Telemetry.js';
-export * from './Admin.js';
 export * from './Connection.js';
 export * from './Generic.js';
 export * from './Provider.js';

packages/shared/lib/seeders/global.seeder.ts

@@ -1,10 +1,9 @@
-import type { User } from '../models/index.js';
 import { seedUser } from './user.seeder.js';
 import { createEnvironmentSeed } from './environment.seeder.js';
 import { createAccount } from './account.seeder.js';
-import type { DBEnvironment, DBTeam } from '@nangohq/types';
+import type { DBEnvironment, DBTeam, DBUser } from '@nangohq/types';
 
-export async function seedAccountEnvAndUser(): Promise<{ account: DBTeam; env: DBEnvironment; user: User }> {
+export async function seedAccountEnvAndUser(): Promise<{ account: DBTeam; env: DBEnvironment; user: DBUser }> {
     const account = await createAccount();
     const env = await createEnvironmentSeed(account.id, 'dev');
     const user = await seedUser(account.id);

packages/shared/lib/seeders/user.seeder.ts

@@ -1,11 +1,11 @@
 import { promisify } from 'node:util';
 import crypto from 'node:crypto';
 import { nanoid } from '@nangohq/utils';
-import type { User } from '../models';
 import userService from '../services/user.service.js';
+import type { DBUser } from '@nangohq/types';
 
 const promisePdkdf2 = promisify(crypto.pbkdf2);
-export async function seedUser(accountId: number): Promise<User> {
+export async function seedUser(accountId: number): Promise<DBUser> {
     const uniqueId = nanoid();
 
     const salt = crypto.randomBytes(16).toString('base64');

packages/shared/lib/services/user.service.ts

@@ -2,20 +2,19 @@ import db from '@nangohq/database';
 import * as uuid from 'uuid';
 import type { Result } from '@nangohq/utils';
 import { Ok, Err } from '@nangohq/utils';
-import type { User } from '../models/Admin.js';
 import type { DBUser } from '@nangohq/types';
 
 const VERIFICATION_EMAIL_EXPIRATION = 3 * 24 * 60 * 60 * 1000;
 
 class UserService {
-    async getUserById(id: number): Promise<User | null> {
-        const result = await db.knex.select<User>('*').from<User>(`_nango_users`).where({ id, suspended: false }).first();
+    async getUserById(id: number): Promise<DBUser | null> {
+        const result = await db.knex.select<DBUser>('*').from<DBUser>(`_nango_users`).where({ id, suspended: false }).first();
 
         return result || null;
     }
 
-    async getUserByUuid(uuid: string): Promise<User | null> {
-        const result = await db.knex.select('*').from<User>(`_nango_users`).where({ uuid }).first();
+    async getUserByUuid(uuid: string): Promise<DBUser | null> {
+        const result = await db.knex.select('*').from<DBUser>(`_nango_users`).where({ uuid }).first();
 
         return result || null;
     }
@@ -36,12 +35,12 @@ class UserService {
         return Err(new Error('user_not_found'));
     }
 
-    async refreshEmailVerificationToken(expiredToken: string): Promise<User | null> {
+    async refreshEmailVerificationToken(expiredToken: string): Promise<DBUser | null> {
         const newToken = uuid.v4();
         const expires_at = new Date(new Date().getTime() + VERIFICATION_EMAIL_EXPIRATION);
 
         const result = await db.knex
-            .from<User>(`_nango_users`)
+            .from<DBUser>(`_nango_users`)
             .where({ email_verification_token: expiredToken })
             .update({
                 email_verification_token: newToken,
@@ -52,26 +51,26 @@ class UserService {
         return result[0] || null;
     }
 
-    async getUsersByAccountId(accountId: number): Promise<User[]> {
-        const result = await db.knex.select('*').from<User>(`_nango_users`).where({ account_id: accountId, suspended: false });
+    async getUsersByAccountId(accountId: number): Promise<DBUser[]> {
+        const result = await db.knex.select('*').from<DBUser>(`_nango_users`).where({ account_id: accountId, suspended: false });
 
         return result;
     }
 
     async countUsers(accountId: number): Promise<number> {
         const result = await db.knex
             .select(db.knex.raw('COUNT(id) as total'))
-            .from<User>(`_nango_users`)
+            .from<DBUser>(`_nango_users`)
             .where({ account_id: accountId, suspended: false })
             .first();
 
-        return result.total || 0;
+        return result.total ? parseInt(result.total, 10) : 0;
     }
 
-    async getAnUserByAccountId(accountId: number): Promise<User | null> {
+    async getAnUserByAccountId(accountId: number): Promise<DBUser | null> {
         const result = await db.knex
             .select('*')
-            .from<User>(`_nango_users`)
+            .from<DBUser>(`_nango_users`)
             .where({
                 account_id: accountId,
                 suspended: false
@@ -86,14 +85,14 @@ class UserService {
         return result[0];
     }
 
-    async getUserByEmail(email: string): Promise<User | null> {
-        const result = await db.knex.select('*').from<User>(`_nango_users`).where({ email: email }).first();
+    async getUserByEmail(email: string): Promise<DBUser | null> {
+        const result = await db.knex.select('*').from<DBUser>(`_nango_users`).where({ email: email }).first();
 
         return result || null;
     }
 
-    async getUserByResetPasswordToken(link: string): Promise<User | null> {
-        const result = await db.knex.select('*').from<User>(`_nango_users`).where({ reset_password_token: link }).first();
+    async getUserByResetPasswordToken(link: string): Promise<DBUser | null> {
+        const result = await db.knex.select('*').from<DBUser>(`_nango_users`).where({ reset_password_token: link }).first();
 
         return result || null;
     }
@@ -112,10 +111,10 @@ class UserService {
         salt?: string;
         account_id: number;
         email_verified: boolean;
-    }): Promise<User | null> {
+    }): Promise<DBUser | null> {
         const expires_at = new Date(new Date().getTime() + VERIFICATION_EMAIL_EXPIRATION);
-        const result: Pick<User, 'id'>[] = await db.knex
-            .from<User>('_nango_users')
+        const result: Pick<DBUser, 'id'>[] = await db.knex
+            .from<DBUser>('_nango_users')
             .insert({
                 email,
                 name,
@@ -136,28 +135,28 @@ class UserService {
         return null;
     }
 
-    async editUserPassword(user: User) {
-        return db.knex.from<User>(`_nango_users`).where({ id: user.id }).update({
+    async editUserPassword(user: Pick<DBUser, 'id' | 'reset_password_token' | 'hashed_password'>) {
+        return db.knex.from<DBUser>(`_nango_users`).where({ id: user.id }).update({
             reset_password_token: user.reset_password_token,
             hashed_password: user.hashed_password
         });
     }
 
     async changePassword(newPassword: string, oldPassword: string, id: number) {
-        return db.knex.from<User>(`_nango_users`).where({ id }).update({
+        return db.knex.from<DBUser>(`_nango_users`).where({ id }).update({
             hashed_password: newPassword,
             salt: oldPassword
         });
     }
 
     async suspendUser(id: number) {
         if (id !== null && id !== undefined) {
-            await db.knex.from<User>(`_nango_users`).where({ id }).update({ suspended: true, suspended_at: new Date() });
+            await db.knex.from<DBUser>(`_nango_users`).where({ id }).update({ suspended: true, suspended_at: new Date() });
         }
     }
 
     async verifyUserEmail(id: number) {
-        return db.knex.from<User>(`_nango_users`).where({ id }).update({ email_verified: true, email_verification_token: null });
+        return db.knex.from<DBUser>(`_nango_users`).where({ id }).update({ email_verified: true, email_verification_token: null });
     }
 
     async update({ id, ...data }: { id: number } & Omit<Partial<DBUser>, 'id'>): Promise<DBUser | null> {

packages/shared/lib/utils/analytics.ts

@@ -5,10 +5,8 @@ import errorManager, { ErrorSourceEnum } from './error.manager.js';
 import accountService from '../services/account.service.js';
 import environmentService from '../services/environment.service.js';
 import userService from '../services/user.service.js';
-import type { User } from '../models/Admin.js';
 import { LogActionEnum } from '../models/Telemetry.js';
 import { NANGO_VERSION } from '../version.js';
-import type { DBTeam } from '@nangohq/types';
 
 export enum AnalyticsTypes {
     ACCOUNT_CREATED = 'server:account_created',
@@ -133,9 +131,9 @@ class Analytics {
             eventProperties['nango-server-version'] = this.packageVersion || 'unknown';
 
             if (isCloud && accountId != null) {
-                const account: DBTeam | null = await accountService.getAccountById(accountId);
+                const account = await accountService.getAccountById(accountId);
                 if (account !== null && account.id !== undefined) {
-                    const users: User[] = await userService.getUsersByAccountId(account.id);
+                    const users = await userService.getUsersByAccountId(account.id);
 
                     if (users.length > 0) {
                         userProperties['email'] = users.map((user) => user.email).join(',');

packages/types/lib/user/db.ts

@@ -7,7 +7,7 @@ export interface DBUser extends Timestamps {
     hashed_password: string;
     salt: string;
     account_id: number;
-    reset_password_token: string | undefined;
+    reset_password_token: string | null;
     suspended: boolean;
     suspended_at: Date;
     email_verified: boolean;