@loomcore/api 0.2.18 → 0.2.20

package/dist/controllers/auth.controller.d.ts

@@ -1,11 +1,21 @@
+import { type IModelSpec } from "@loomcore/common/models";
 import type { Application, Request, Response } from "express";
 import type { IDatabase } from "../databases/models/index.js";
 import { OrganizationService, UserService } from "../services/index.js";
+export interface AuthControllerOptions {
+    userService?: UserService;
+    userSpec?: IModelSpec;
+    publicUserSpec?: IModelSpec;
+}
 export declare class AuthController {
     database: IDatabase;
     userService: UserService;
     organizationService: OrganizationService;
-    constructor(app: Application, database: IDatabase);
+    userSpec: IModelSpec;
+    publicUserSpec: IModelSpec;
+    publicUserContextSpec: IModelSpec;
+    loginResponseSpec: IModelSpec;
+    constructor(app: Application, database: IDatabase, options?: AuthControllerOptions);
     mapRoutes(app: Application): void;
     login(req: Request, res: Response): Promise<void>;
     requestTokenUsingRefreshToken(req: Request, res: Response): Promise<void>;

package/dist/controllers/auth.controller.js

@@ -1,19 +1,35 @@
-import { EmptyUserContext, LoginResponseSpec, PublicUserContextSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
+import { EmptyUserContext, passwordValidator, TokenResponseSpec, } from "@loomcore/common/models";
 import { entityUtils } from "@loomcore/common/utils";
 import { config } from "../config/base-api-config.js";
 import { BadRequestError, UnauthenticatedError } from "../errors/index.js";
 import { isAuthorized } from "../middleware/index.js";
 import { OrganizationService, UserService } from "../services/index.js";
-import { attemptLogin, changePassword, getAndSetDeviceIdCookie, getDeviceIdFromCookie, requestTokenUsingRefreshToken, resetPassword, sendResetPasswordEmail, } from "../utils/auth/index.js";
+import { attemptLogin, changePassword, createUserContextSpec, getAndSetDeviceIdCookie, getDeviceIdFromCookie, requestTokenUsingRefreshToken, resetPassword, resolveAuthUserSpecs, sendResetPasswordEmail, setAuthUserContextSpec, } from "../utils/auth/index.js";
 import { apiUtils } from "../utils/index.js";
 export class AuthController {
     database;
     userService;
     organizationService;
-    constructor(app, database) {
+    userSpec;
+    publicUserSpec;
+    publicUserContextSpec;
+    loginResponseSpec;
+    constructor(app, database, options = {}) {
         this.database = database;
-        this.userService = new UserService(database);
+        const resolved = resolveAuthUserSpecs({
+            userSpec: options.userSpec,
+            publicUserSpec: options.publicUserSpec,
+        });
+        this.userSpec = resolved.userSpec;
+        this.publicUserSpec = resolved.publicUserSpec;
+        this.publicUserContextSpec = resolved.publicUserContextSpec;
+        this.loginResponseSpec = resolved.loginResponseSpec;
+        this.userService =
+            options.userService ?? new UserService(database, this.userSpec);
         this.organizationService = new OrganizationService(database);
+        if (options.userSpec) {
+            setAuthUserContextSpec(createUserContextSpec(this.userSpec));
+        }
         this.mapRoutes(app);
     }
     mapRoutes(app) {
@@ -45,8 +61,8 @@ export class AuthController {
         }
         res.set("Content-Type", "application/json");
         const deviceId = getAndSetDeviceIdCookie(req, res);
-        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organization);
-        apiUtils.apiResponse(res, 200, { data: loginResponse }, LoginResponseSpec);
+        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organization, this.userService);
+        apiUtils.apiResponse(res, 200, { data: loginResponse }, this.loginResponseSpec);
     }
     async requestTokenUsingRefreshToken(req, res) {
         const userContext = req.userContext;
@@ -66,7 +82,7 @@ export class AuthController {
     }
     async getUserContext(req, res) {
         const userContext = req.userContext;
-        apiUtils.apiResponse(res, 200, { data: userContext }, PublicUserContextSpec);
+        apiUtils.apiResponse(res, 200, { data: userContext }, this.publicUserContextSpec);
     }
     afterAuth(_req, _res, _loginResponse) {
         console.log("in afterAuth");
@@ -77,9 +93,9 @@ export class AuthController {
             throw new BadRequestError("Missing required fields: userContext is required.");
         }
         const password = req.body?.password;
-        const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
+        const validationErrors = entityUtils.validate(this.userSpec, { password: password }, true, passwordValidator);
         entityUtils.handleValidationResult(validationErrors, "AuthController.changePassword");
-        const updateResult = await changePassword(this.database, userContext, password);
+        const updateResult = await changePassword(this.database, userContext, password, this.userService);
         apiUtils.apiResponse(res, 200, { data: updateResult });
     }
     async forgotPassword(req, res) {
@@ -127,7 +143,7 @@ export class AuthController {
                 throw new BadRequestError("Missing required fields: organization is required.");
             }
         }
-        const response = await resetPassword(this.database, email, token, password, organization);
+        const response = await resetPassword(this.database, email, token, password, organization, this.userService, this.userSpec);
         apiUtils.apiResponse(res, 200, { data: response });
     }
 }

package/dist/controllers/users.controller.d.ts

@@ -1,9 +1,14 @@
-import { type IUser } from "@loomcore/common/models";
+import { type IModelSpec, type IUser } from "@loomcore/common/models";
 import type { Application } from "express";
 import type { IDatabase } from "../databases/models/index.js";
 import { UserService } from "../services/index.js";
 import { ApiController } from "./api.controller.js";
+export interface UsersControllerOptions {
+    userService?: UserService;
+    userSpec?: IModelSpec;
+    publicUserSpec?: IModelSpec;
+}
 export declare class UsersController extends ApiController<IUser> {
     userService: UserService;
-    constructor(app: Application, database: IDatabase);
+    constructor(app: Application, database: IDatabase, options?: UsersControllerOptions);
 }

package/dist/controllers/users.controller.js

@@ -1,11 +1,13 @@
-import { PublicUserSpec, UserSpec } from "@loomcore/common/models";
+import { PublicUserSpec, UserSpec, } from "@loomcore/common/models";
 import { UserService } from "../services/index.js";
 import { ApiController } from "./api.controller.js";
 export class UsersController extends ApiController {
     userService;
-    constructor(app, database) {
-        const userService = new UserService(database);
-        super("users", app, userService, "user", UserSpec, PublicUserSpec);
+    constructor(app, database, options = {}) {
+        const userSpec = options.userSpec ?? UserSpec;
+        const publicUserSpec = options.publicUserSpec ?? PublicUserSpec;
+        const userService = options.userService ?? new UserService(database, userSpec);
+        super("users", app, userService, "user", userSpec, publicUserSpec);
         this.userService = userService;
     }
 }

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.js

@@ -1,5 +1,9 @@
+import { LeftJoin } from "../../operations/left-join.operation.js";
+import { InnerJoin } from "../../operations/inner-join.operation.js";
+import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
 import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
 export async function fullUpdateById(client, operations, id, entity, pluralResourceName) {
     try {
         const tableColumns = await client.query(`
@@ -49,16 +53,25 @@ export async function fullUpdateById(client, operations, id, entity, pluralResou
         if (result.rowCount === 0) {
             throw new IdNotFoundError();
         }
-        const joinClauses = buildJoinClauses(operations, pluralResourceName);
+        const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
+        const joinClauses = hasJoins
+            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
+            : buildJoinClauses(operations, pluralResourceName);
+        const selectClause = hasJoins
+            ? await buildSelectClause(client, pluralResourceName, operations)
+            : '*';
+        const idColumn = hasJoins ? `"${pluralResourceName}"."_id"` : '"_id"';
         const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            WHERE "_id" = $1 LIMIT 1
+            SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}
+            WHERE ${idColumn} = $1 LIMIT 1
         `;
         const selectResult = await client.query(selectQuery, [id]);
         if (selectResult.rows.length === 0) {
             throw new IdNotFoundError();
         }
-        return selectResult.rows[0];
+        return hasJoins
+            ? selectResult.rows[0].entity
+            : selectResult.rows[0];
     }
     catch (err) {
         if (err instanceof IdNotFoundError) {

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.js

@@ -1,5 +1,9 @@
+import { LeftJoin } from "../../operations/left-join.operation.js";
+import { InnerJoin } from "../../operations/inner-join.operation.js";
+import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
 import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 export async function partialUpdateById(client, operations, id, entity, pluralResourceName) {
     try {
@@ -19,16 +23,25 @@ export async function partialUpdateById(client, operations, id, entity, pluralRe
         if (result.rowCount === 0) {
             throw new IdNotFoundError();
         }
-        const joinClauses = buildJoinClauses(operations, pluralResourceName);
+        const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
+        const joinClauses = hasJoins
+            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
+            : buildJoinClauses(operations, pluralResourceName);
+        const selectClause = hasJoins
+            ? await buildSelectClause(client, pluralResourceName, operations)
+            : '*';
+        const idColumn = hasJoins ? `"${pluralResourceName}"."_id"` : '"_id"';
         const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            WHERE "_id" = $1 LIMIT 1
+            SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}
+            WHERE ${idColumn} = $1 LIMIT 1
         `;
         const selectResult = await client.query(selectQuery, [id]);
         if (selectResult.rows.length === 0) {
             throw new IdNotFoundError();
         }
-        return selectResult.rows[0];
+        return hasJoins
+            ? selectResult.rows[0].entity
+            : selectResult.rows[0];
     }
     catch (err) {
         if (err instanceof IdNotFoundError) {

package/dist/databases/postgres/commands/postgres-update.command.js

@@ -1,7 +1,11 @@
+import { LeftJoin } from "../../operations/left-join.operation.js";
+import { InnerJoin } from "../../operations/inner-join.operation.js";
+import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
 import { BadRequestError, NotFoundError } from "../../../errors/index.js";
 import { buildWhereClause } from '../utils/build-where-clause.js';
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildOrderByClause } from '../utils/build-order-by-clause.js';
+import { buildSelectClause } from '../utils/build-select-clause.js';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 export async function update(client, queryObject, entity, operations, pluralResourceName) {
     try {
@@ -27,14 +31,24 @@ export async function update(client, queryObject, entity, operations, pluralReso
         if (result.rowCount === 0) {
             throw new NotFoundError('No records found matching update query');
         }
-        const joinClauses = buildJoinClauses(operations, pluralResourceName);
-        const orderByClause = buildOrderByClause(queryObject);
+        const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
+        const joinClauses = hasJoins
+            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
+            : buildJoinClauses(operations, pluralResourceName);
+        const orderByClause = buildOrderByClause(queryObject, hasJoins ? { tablePrefix: pluralResourceName } : undefined);
+        const tablePrefix = hasJoins ? pluralResourceName : undefined;
+        const { whereClause: selectWhereClause, values: selectWhereValues } = buildWhereClause(queryObject, [], tablePrefix);
+        const selectClause = hasJoins
+            ? await buildSelectClause(client, pluralResourceName, operations)
+            : '*';
         const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
-            ${whereClause} ${orderByClause}
+            SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}
+            ${selectWhereClause} ${orderByClause}
         `.trim();
-        const selectResult = await client.query(selectQuery, whereValues);
-        return selectResult.rows;
+        const selectResult = await client.query(selectQuery, selectWhereValues);
+        return hasJoins
+            ? selectResult.rows.map(r => r.entity)
+            : selectResult.rows;
     }
     catch (err) {
         if (err instanceof NotFoundError) {

package/dist/middleware/is-authorized.js

@@ -1,6 +1,6 @@
-import { UserContextSpec } from "@loomcore/common/models";
 import jwt from "jsonwebtoken";
 import { UnauthenticatedError, UnauthorizedError } from "../errors/index.js";
+import { getAuthUserContextSpec } from "../utils/auth/auth-user-specs.util.js";
 import { getAuthConfig } from "../utils/auth/get-auth-config.util.js";
 const isAuthorized = (allowedFeatures) => {
     return (req, _res, next) => {
@@ -18,7 +18,7 @@ const isAuthorized = (allowedFeatures) => {
         const authConfig = getAuthConfig();
         try {
             const rawPayload = jwt.verify(token, authConfig.clientSecret);
-            const userContext = UserContextSpec.decode(rawPayload);
+            const userContext = getAuthUserContextSpec().decode(rawPayload);
             req.userContext = userContext;
             if (userContext.authorizations.some((authorization) => authorization.feature === "admin")) {
                 next();

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

@@ -1,9 +1,9 @@
-import { type IQueryOptions, type IUser, type IUserContext } from "@loomcore/common/models";
+import { type IModelSpec, type IQueryOptions, 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);
+    constructor(database: IDatabase, modelSpec?: IModelSpec);
     fullUpdateById(_userContext: IUserContext, _id: AppIdType, _entity: IUser): Promise<IUser>;
     update(userContext: IUserContext, queryObject: IQueryOptions, entity: Partial<IUser>): Promise<IUser[]>;
     batchUpdate(userContext: IUserContext, entities: Partial<IUser>[]): Promise<IUser[]>;

package/dist/services/user.service.js

@@ -3,8 +3,8 @@ import { BadRequestError, ServerError } from "../errors/index.js";
 import { passwordUtils } from "../utils/password.utils.js";
 import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export class UserService extends MultiTenantApiService {
-    constructor(database) {
-        super(database, "users", "user", UserSpec);
+    constructor(database, modelSpec = UserSpec) {
+        super(database, "users", "user", modelSpec);
     }
     async fullUpdateById(_userContext, _id, _entity) {
         throw new ServerError("User full update is not allowed.");

package/dist/utils/auth/attempt-login.util.d.ts

@@ -1,3 +1,4 @@
 import { type ILoginResponse, type IOrganization } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
-export declare function attemptLogin(database: IDatabase, email: string, password: string, deviceId: string, organization: IOrganization | null): Promise<ILoginResponse | null>;
+import { UserService } from "../../services/user.service.js";
+export declare function attemptLogin(database: IDatabase, email: string, password: string, deviceId: string, organization: IOrganization | null, userService?: UserService): Promise<ILoginResponse | null>;

package/dist/utils/auth/attempt-login.util.js

@@ -4,13 +4,12 @@ import { UserService } from "../../services/user.service.js";
 import { getUserContextAuthorizations } from "../../services/utils/getUserContextAuthorizations.util.js";
 import { passwordUtils } from "../password.utils.js";
 import { logUserIn } from "./log-user-in.util.js";
-export async function attemptLogin(database, email, password, deviceId, organization) {
+export async function attemptLogin(database, email, password, deviceId, organization, userService = new UserService(database)) {
     const lowerCaseEmail = email.toLowerCase();
     const userContext = {
         ...EmptyUserContext,
         organization: organization ?? undefined,
     };
-    const userService = new UserService(database);
     const user = await userService.findOne(userContext, {
         filters: {
             email: { eq: lowerCaseEmail },
@@ -29,7 +28,7 @@ export async function attemptLogin(database, email, password, deviceId, organiza
         organization: organization ?? undefined,
         authorizations: authorizations,
     };
-    const tokens = await logUserIn(database, authenticatedUserContext, deviceId);
+    const tokens = await logUserIn(database, authenticatedUserContext, deviceId, userService);
     return {
         tokens,
         userContext: authenticatedUserContext,

package/dist/utils/auth/auth-user-specs.util.d.ts

@@ -0,0 +1,15 @@
+import { type IModelSpec } from "@loomcore/common/models";
+export declare function createUserContextSpec(userModelSpec: IModelSpec): IModelSpec;
+export declare function createLoginResponseSpec(publicUserContextSpec: IModelSpec): IModelSpec;
+export declare function setAuthUserContextSpec(spec: IModelSpec): void;
+export declare function getAuthUserContextSpec(): IModelSpec;
+export declare function resetAuthUserContextSpec(): void;
+export declare function resolveAuthUserSpecs(options: {
+    userSpec?: IModelSpec;
+    publicUserSpec?: IModelSpec;
+}): {
+    userSpec: IModelSpec;
+    publicUserSpec: IModelSpec;
+    publicUserContextSpec: IModelSpec;
+    loginResponseSpec: IModelSpec;
+};

package/dist/utils/auth/auth-user-specs.util.js

@@ -0,0 +1,38 @@
+import { OrganizationSpec, PublicUserSpec, TokenResponseSchema, UserContextAuthorizationSpec, UserContextSpec, UserSpec, } from "@loomcore/common/models";
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export function createUserContextSpec(userModelSpec) {
+    return entityUtils.getModelSpec(Type.Object({
+        user: userModelSpec.fullSchema,
+        authorizations: Type.Array(UserContextAuthorizationSpec.fullSchema),
+        organization: OrganizationSpec.fullSchema,
+    }), { isEntity: false });
+}
+export function createLoginResponseSpec(publicUserContextSpec) {
+    return entityUtils.getModelSpec(Type.Object({
+        tokens: TokenResponseSchema,
+        userContext: publicUserContextSpec.fullSchema,
+    }), { isEntity: false });
+}
+let authUserContextSpec = UserContextSpec;
+export function setAuthUserContextSpec(spec) {
+    authUserContextSpec = spec;
+}
+export function getAuthUserContextSpec() {
+    return authUserContextSpec;
+}
+export function resetAuthUserContextSpec() {
+    authUserContextSpec = UserContextSpec;
+}
+export function resolveAuthUserSpecs(options) {
+    const userSpec = options.userSpec ?? UserSpec;
+    const publicUserSpec = options.publicUserSpec ?? PublicUserSpec;
+    const publicUserContextSpec = createUserContextSpec(publicUserSpec);
+    const loginResponseSpec = createLoginResponseSpec(publicUserContextSpec);
+    return {
+        userSpec,
+        publicUserSpec,
+        publicUserContextSpec,
+        loginResponseSpec,
+    };
+}

package/dist/utils/auth/change-password.util.d.ts

@@ -1,4 +1,5 @@
 import type { IUserContext } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
 import type { UpdateResult } from "../../databases/models/update-result.js";
-export declare function changePassword(database: IDatabase, userContext: IUserContext, password: string): Promise<UpdateResult>;
+import { UserService } from "../../services/user.service.js";
+export declare function changePassword(database: IDatabase, userContext: IUserContext, password: string, userService?: UserService): Promise<UpdateResult>;

package/dist/utils/auth/change-password.util.js

@@ -1,7 +1,6 @@
 import moment from "moment";
 import { UserService } from "../../services/user.service.js";
-export async function changePassword(database, userContext, password) {
-    const userService = new UserService(database);
+export async function changePassword(database, userContext, password, userService = new UserService(database)) {
     const updates = {
         password: password,
         _lastPasswordChange: moment().utc().toDate(),

package/dist/utils/auth/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./attempt-login.util.js";
+export * from "./auth-user-specs.util.js";
 export * from "./change-password.util.js";
 export * from "./create-new-refresh-token.util.js";
 export * from "./create-new-tokens.util.js";

package/dist/utils/auth/index.js

@@ -1,4 +1,5 @@
 export * from "./attempt-login.util.js";
+export * from "./auth-user-specs.util.js";
 export * from "./change-password.util.js";
 export * from "./create-new-refresh-token.util.js";
 export * from "./create-new-tokens.util.js";

package/dist/utils/auth/log-user-in.util.d.ts

@@ -1,3 +1,4 @@
 import type { ITokenResponse, IUserContext } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
-export declare function logUserIn(database: IDatabase, userContext: IUserContext, deviceId: string): Promise<ITokenResponse>;
+import type { UserService } from "../../services/user.service.js";
+export declare function logUserIn(database: IDatabase, userContext: IUserContext, deviceId: string, userService?: UserService): Promise<ITokenResponse>;

package/dist/utils/auth/log-user-in.util.js

@@ -3,7 +3,7 @@ import { createNewRefreshToken } from "./create-new-refresh-token.util.js";
 import { getAuthConfig } from "./get-auth-config.util.js";
 import { getExpiresOnFromSeconds } from "./get-expires-on-from-seconds.util.js";
 import { updateLastLoggedIn } from "./update-last-logged-in.util.js";
-export async function logUserIn(database, userContext, deviceId) {
+export async function logUserIn(database, userContext, deviceId, userService) {
     const authConfig = getAuthConfig();
     const accessToken = generateJwt(userContext);
     const refreshTokenObject = await createNewRefreshToken(database, userContext.user._id, deviceId, userContext.organization?._id);
@@ -13,6 +13,6 @@ export async function logUserIn(database, userContext, deviceId) {
         refreshToken: refreshTokenObject.token,
         expiresOn: accessTokenExpiresOn,
     };
-    updateLastLoggedIn(database, userContext.user._id).catch((err) => console.log(`Error updating lastLoggedIn: ${err}`));
+    updateLastLoggedIn(database, userContext.user._id, userService).catch((err) => console.log(`Error updating lastLoggedIn: ${err}`));
     return tokenResponse;
 }

package/dist/utils/auth/reset-password.util.d.ts

@@ -1,4 +1,5 @@
-import { type IOrganization } from "@loomcore/common/models";
+import { type IModelSpec, type IOrganization } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
 import type { UpdateResult } from "../../databases/models/update-result.js";
-export declare function resetPassword(database: IDatabase, email: string, passwordResetToken: string, password: string, organization: IOrganization | null): Promise<UpdateResult>;
+import { UserService } from "../../services/user.service.js";
+export declare function resetPassword(database: IDatabase, email: string, passwordResetToken: string, password: string, organization: IOrganization | null, userService?: UserService, userSpec?: IModelSpec): Promise<UpdateResult>;

package/dist/utils/auth/reset-password.util.js

@@ -4,12 +4,11 @@ import { BadRequestError, ServerError } from "../../errors/index.js";
 import { PasswordResetTokenService } from "../../services/password-reset-token.service.js";
 import { UserService } from "../../services/user.service.js";
 import { changePassword } from "./change-password.util.js";
-export async function resetPassword(database, email, passwordResetToken, password, organization) {
-    const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
+export async function resetPassword(database, email, passwordResetToken, password, organization, userService = new UserService(database), userSpec = UserSpec) {
+    const validationErrors = entityUtils.validate(userSpec, { password: password }, true, passwordValidator);
     entityUtils.handleValidationResult(validationErrors, "AuthService.resetPassword");
     const lowerCaseEmail = email.toLowerCase();
     const passwordResetTokenService = new PasswordResetTokenService(database);
-    const userService = new UserService(database);
     const userContext = {
         ...EmptyUserContext,
         organization: organization ?? undefined,
@@ -31,7 +30,7 @@ export async function resetPassword(database, email, passwordResetToken, passwor
         throw new ServerError(`Unable to retrieve user for email: ${lowerCaseEmail}`);
     }
     userContext.user = user;
-    const result = await changePassword(database, userContext, password);
+    const result = await changePassword(database, userContext, password, userService);
     console.log(`password changed using forgot-password for email: ${lowerCaseEmail}`);
     await passwordResetTokenService.deleteById(userContext, retrievedPasswordResetToken._id);
     console.log(`passwordResetToken deleted for email: ${lowerCaseEmail}`);

package/dist/utils/auth/update-last-logged-in.util.d.ts

@@ -1,3 +1,4 @@
 import type { AppIdType } from "@loomcore/common/types";
 import type { IDatabase } from "../../databases/models/index.js";
-export declare function updateLastLoggedIn(database: IDatabase, userId: AppIdType): Promise<void>;
+import { UserService } from "../../services/user.service.js";
+export declare function updateLastLoggedIn(database: IDatabase, userId: AppIdType, userService?: UserService): Promise<void>;

package/dist/utils/auth/update-last-logged-in.util.js

@@ -1,12 +1,11 @@
 import { getSystemUserContext } from "@loomcore/common/models";
 import moment from "moment";
 import { UserService } from "../../services/user.service.js";
-export async function updateLastLoggedIn(database, userId) {
+export async function updateLastLoggedIn(database, userId, userService = new UserService(database)) {
     try {
         const updates = {
             _lastLoggedIn: moment().utc().toDate(),
         };
-        const userService = new UserService(database);
         await userService.update(getSystemUserContext(), { filters: { _id: { eq: userId } } }, updates);
     }
     catch (error) {

package/package.json

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