@loomcore/api 0.0.58 → 0.1.0

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

@@ -1,12 +1,14 @@
-import { Db, UpdateResult } from 'mongodb';
 import { Request, Response } from 'express';
 import { IUserContext, IUser, ITokenResponse, ILoginResponse } from '@loomcore/common/models';
-import { GenericApiService } from './generic-api.service.js';
+import { GenericApiService } from './generic-api-service/generic-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> {
-    private refreshTokensCollection;
+    private refreshTokenService;
     private passwordResetTokenService;
     private emailService;
-    constructor(db: Db);
+    constructor(database: IDatabase);
     attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
     logUserIn(userContext: IUserContext, deviceId: string): Promise<{
         tokens: {
@@ -20,25 +22,18 @@ export declare class AuthService extends GenericApiService<IUser> {
     getUserByEmail(email: string): Promise<IUser | null>;
     createUser(userContext: IUserContext, user: IUser): Promise<IUser | null>;
     requestTokenUsingRefreshToken(req: Request): Promise<ITokenResponse | null>;
-    changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult<import("bson").Document>>;
+    changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult>;
     changePassword(userContext: IUserContext, queryObject: any, password: string): Promise<UpdateResult>;
     createNewTokens(userId: string, deviceId: string, refreshTokenExpiresOn: number): Promise<{
         accessToken: string;
         refreshToken: any;
         expiresOn: number;
     } | null>;
-    getActiveRefreshToken(refreshToken: string, deviceId: string): Promise<import("mongodb").WithId<import("bson").Document> | null>;
-    createNewRefreshToken(userId: string, deviceId: string, existingExpiresOn?: number | null): Promise<{
-        token: string;
-        deviceId: string;
-        userId: string;
-        expiresOn: number;
-        created: Date;
-        createdBy: string;
-    } | 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("mongodb").DeleteResult>;
+    deleteRefreshTokensForDevice(deviceId: string): Promise<import("../databases/models/delete-result.js").DeleteResult>;
     generateJwt(payload: any): string;
     generateRefreshToken(): string;
     generateDeviceId(): string;
@@ -47,8 +42,6 @@ export declare class AuthService extends GenericApiService<IUser> {
     getExpiresOnFromSeconds(expiresInSeconds: number): number;
     getExpiresOnFromMinutes(expiresInMinutes: number): number;
     getExpiresOnFromDays(expiresInDays: number): number;
-    prepareEntity(userContext: IUserContext, entity: IUser | Partial<IUser>, isCreate: boolean): Promise<IUser | Partial<IUser>>;
-    transformList(users: IUser[]): IUser[];
-    transformSingle(user: IUser): IUser;
+    preprocessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId: boolean): Promise<Partial<IUser>>;
     private updateLastLoggedIn;
 }

package/dist/services/auth.service.js

@@ -1,22 +1,22 @@
-import { ObjectId } from 'mongodb';
 import moment from 'moment';
 import crypto from 'crypto';
 import { EmptyUserContext, passwordValidator, UserSpec, getSystemUserContext } from '@loomcore/common/models';
 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.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 import { PasswordResetTokenService } from './password-reset-token.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 {
-    refreshTokensCollection;
+    refreshTokenService;
     passwordResetTokenService;
     emailService;
-    constructor(db) {
-        super(db, 'users', 'user', UserSpec);
-        this.refreshTokensCollection = db.collection('refreshTokens');
-        this.passwordResetTokenService = new PasswordResetTokenService(db);
+    constructor(database) {
+        super(database, 'users', 'user', UserSpec);
+        this.refreshTokenService = new GenericApiService(database, 'refreshTokens', 'refreshToken', refreshTokenModelSpec);
+        this.passwordResetTokenService = new PasswordResetTokenService(database);
         this.emailService = new EmailService();
     }
     async attemptLogin(req, res, email, password) {
@@ -40,7 +40,7 @@ export class AuthService extends GenericApiService {
     async logUserIn(userContext, deviceId) {
         const payload = userContext;
         const accessToken = this.generateJwt(payload);
-        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id.toString(), deviceId);
+        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id, deviceId, null, userContext._orgId);
         const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
         let loginResponse = null;
         if (refreshTokenObject) {
@@ -51,20 +51,17 @@ export class AuthService extends GenericApiService {
             };
             this.updateLastLoggedIn(userContext.user._id)
                 .catch(err => console.log(`Error updating lastLoggedIn: ${err}`));
-            userContext.user = this.transformSingle(userContext.user);
+            userContext.user = this.postprocessEntity(userContext, userContext.user);
             loginResponse = { tokens: tokenResponse, userContext };
         }
         return loginResponse;
     }
     async getUserById(id) {
-        if (!entityUtils.isValidObjectId(id)) {
-            throw new BadRequestError('id is not a valid ObjectId');
-        }
-        const user = await this.findOne(EmptyUserContext, { _id: new ObjectId(id) });
+        const user = await this.findOne(EmptyUserContext, { filters: { _id: { eq: id } } });
         return user;
     }
     async getUserByEmail(email) {
-        const user = await this.findOne(EmptyUserContext, { email: email.toLowerCase() });
+        const user = await this.findOne(EmptyUserContext, { filters: { email: { eq: email.toLowerCase() } } });
         return user;
     }
     async createUser(userContext, user) {
@@ -75,9 +72,9 @@ export class AuthService extends GenericApiService {
         const refreshToken = req.query.refreshToken;
         const deviceId = this.getDeviceIdFromCookie(req);
         let tokens = null;
-        if (refreshToken && typeof refreshToken === 'string' && deviceId) {
+        if (refreshToken && typeof refreshToken === 'string' && deviceId && typeof deviceId === 'string') {
             let userId = null;
-            const activeRefreshToken = await this.getActiveRefreshToken(refreshToken, deviceId);
+            const activeRefreshToken = await this.getActiveRefreshToken(EmptyUserContext, refreshToken, deviceId);
             if (activeRefreshToken) {
                 userId = activeRefreshToken.userId;
                 if (userId) {
@@ -88,36 +85,31 @@ export class AuthService extends GenericApiService {
         return tokens;
     }
     async changeLoggedInUsersPassword(userContext, body) {
-        const queryObject = { _id: new ObjectId(userContext.user._id) };
+        const queryObject = { _id: userContext.user._id };
         const result = await this.changePassword(userContext, queryObject, body.password);
         return result;
     }
     async changePassword(userContext, queryObject, password) {
-        const hashedPassword = await passwordUtils.hashPassword(password);
-        const updates = { password: hashedPassword, _lastPasswordChange: moment().utc().toDate() };
+        const updates = { password: password, _lastPasswordChange: moment().utc().toDate() };
         const updatedUsers = await super.update(userContext, queryObject, updates);
         const result = {
-            acknowledged: true,
-            modifiedCount: updatedUsers.length,
-            upsertedId: null,
-            upsertedCount: 0,
-            matchedCount: updatedUsers.length
+            success: true,
+            count: updatedUsers.length,
         };
         return result;
     }
     async createNewTokens(userId, deviceId, refreshTokenExpiresOn) {
         let createdRefreshTokenObject = null;
-        const newRefreshToken = await this.createNewRefreshToken(userId, deviceId, refreshTokenExpiresOn);
-        let user = null;
+        const user = await this.getUserById(userId);
+        const newRefreshToken = await this.createNewRefreshToken(userId, deviceId, refreshTokenExpiresOn, user?._orgId);
         if (newRefreshToken) {
             createdRefreshTokenObject = newRefreshToken;
-            user = await this.getUserById(userId);
         }
         let tokenResponse = null;
         if (user && createdRefreshTokenObject) {
             const payload = {
                 user: user,
-                _orgId: user._orgId ? String(user._orgId) : undefined
+                _orgId: user._orgId
             };
             const accessToken = this.generateJwt(payload);
             const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
@@ -129,8 +121,8 @@ export class AuthService extends GenericApiService {
         }
         return tokenResponse;
     }
-    async getActiveRefreshToken(refreshToken, deviceId) {
-        const refreshTokenResult = await this.refreshTokensCollection.findOne({ token: refreshToken, deviceId: deviceId });
+    async getActiveRefreshToken(userContext, refreshToken, deviceId) {
+        const refreshTokenResult = await this.refreshTokenService.findOne(userContext, { filters: { token: { eq: refreshToken }, deviceId: { eq: deviceId } } });
         let activeRefreshToken = null;
         if (refreshTokenResult) {
             const now = Date.now();
@@ -141,9 +133,10 @@ export class AuthService extends GenericApiService {
         }
         return activeRefreshToken;
     }
-    async createNewRefreshToken(userId, deviceId, existingExpiresOn = null) {
+    async createNewRefreshToken(userId, deviceId, existingExpiresOn = null, orgId) {
         const expiresOn = existingExpiresOn ? existingExpiresOn : this.getExpiresOnFromDays(config.auth.refreshTokenExpirationInDays);
         const newRefreshToken = {
+            _orgId: orgId,
             token: this.generateRefreshToken(),
             deviceId,
             userId,
@@ -152,12 +145,8 @@ export class AuthService extends GenericApiService {
             createdBy: userId
         };
         const deleteResult = await this.deleteRefreshTokensForDevice(deviceId);
-        const insertResult = await this.refreshTokensCollection.insertOne(newRefreshToken);
-        let tokenResult = null;
-        if (insertResult.insertedId) {
-            tokenResult = newRefreshToken;
-        }
-        return tokenResult;
+        const insertResult = await this.refreshTokenService.create(EmptyUserContext, newRefreshToken);
+        return insertResult;
     }
     async sendResetPasswordEmail(emailAddress) {
         const expiresOn = this.getExpiresOnFromMinutes(config.auth.passwordResetTokenExpirationInMinutes);
@@ -190,7 +179,7 @@ export class AuthService extends GenericApiService {
         return result;
     }
     deleteRefreshTokensForDevice(deviceId) {
-        return this.refreshTokensCollection.deleteMany({ deviceId: deviceId });
+        return this.refreshTokenService.deleteMany(EmptyUserContext, { filters: { deviceId: { eq: deviceId } } });
     }
     generateJwt(payload) {
         if (payload._orgId !== undefined) {
@@ -242,7 +231,7 @@ export class AuthService extends GenericApiService {
     getExpiresOnFromDays(expiresInDays) {
         return Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
     }
-    async prepareEntity(userContext, entity, isCreate) {
+    async preprocessEntity(userContext, entity, isCreate, allowId) {
         if (entity.email) {
             entity.email = entity.email.toLowerCase();
         }
@@ -253,26 +242,16 @@ export class AuthService extends GenericApiService {
         if (isCreate && !entity.roles) {
             entity.roles = ["user"];
         }
-        const preparedEntity = await super.prepareEntity(userContext, entity, isCreate);
+        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
         return preparedEntity;
     }
-    transformList(users) {
-        return super.transformList(users);
-    }
-    transformSingle(user) {
-        return super.transformSingle(user);
-    }
     async updateLastLoggedIn(userId) {
         try {
-            if (!entityUtils.isValidObjectId(userId)) {
-                throw new BadRequestError('userId is not a valid ObjectId');
-            }
             const updates = { _lastLoggedIn: moment().utc().toDate() };
             const systemUserContext = getSystemUserContext();
             await this.partialUpdateById(systemUserContext, userId, updates);
         }
         catch (error) {
-            console.log(`Failed to update lastLoggedIn for user ${userId}: ${error}`);
         }
     }
 }

package/dist/services/generic-api-service/generic-api-service.interface.d.ts

@@ -0,0 +1,29 @@
+import { ValueError } from '@sinclair/typebox/errors';
+import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
+import { DeleteResult } from '../../databases/models/delete-result.js';
+import { Operation } from '../../databases/operations/operation.js';
+export interface IGenericApiService<T extends IEntity> {
+    validate(doc: any, isPartial?: boolean): ValueError[] | null;
+    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
+    prepareQuery(userContext: IUserContext | undefined, queryObject: IQueryOptions, operations: Operation[]): {
+        queryObject: IQueryOptions;
+        operations: Operation[];
+    };
+    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId: boolean): Promise<Partial<T>>;
+    postprocessEntity(userContext: IUserContext, entity: T): T;
+    getAll(userContext: IUserContext): Promise<T[]>;
+    get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
+    getById(userContext: IUserContext, id: string): Promise<T>;
+    getCount(userContext: IUserContext): Promise<number>;
+    create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
+    createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
+    batchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    update(userContext: IUserContext, queryObject: IQueryOptions, entity: Partial<T>): Promise<T[]>;
+    deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
+    deleteMany(userContext: IUserContext, queryObject: IQueryOptions): Promise<DeleteResult>;
+    find(userContext: IUserContext, queryObject: IQueryOptions, options?: any): Promise<T[]>;
+    findOne(userContext: IUserContext, queryObject: IQueryOptions, options?: any): Promise<T | null>;
+}

package/dist/services/generic-api-service/generic-api-service.interface.js

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

package/dist/services/generic-api-service/generic-api.service.d.ts

@@ -0,0 +1,37 @@
+import { ValueError } from '@sinclair/typebox/errors';
+import { IUserContext, IEntity, IQueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import { IGenericApiService } from './generic-api-service.interface.js';
+import { Operation } from '../../databases/operations/operation.js';
+import { DeleteResult } from '../../databases/models/delete-result.js';
+import { IDatabase } from '../../databases/models/index.js';
+export declare class GenericApiService<T extends IEntity> implements IGenericApiService<T> {
+    protected database: IDatabase;
+    protected pluralResourceName: string;
+    protected singularResourceName: string;
+    protected modelSpec: IModelSpec;
+    constructor(database: IDatabase, pluralResourceName: string, singularResourceName: string, modelSpec: IModelSpec);
+    getAll(userContext: IUserContext): Promise<T[]>;
+    prepareQuery(userContext: IUserContext | undefined, queryObject: IQueryOptions, operations: Operation[]): {
+        queryObject: IQueryOptions;
+        operations: Operation[];
+    };
+    validate(doc: any, isPartial?: boolean): ValueError[] | null;
+    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
+    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
+    postprocessEntity(userContext: IUserContext, entity: T): T;
+    get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
+    protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
+    getById(userContext: IUserContext, id: string): Promise<T>;
+    getCount(userContext: IUserContext): Promise<number>;
+    create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
+    createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
+    batchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    update(userContext: IUserContext, queryObject: IQueryOptions, entity: Partial<T>): Promise<T[]>;
+    deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
+    deleteMany(userContext: IUserContext, queryObject: IQueryOptions): Promise<DeleteResult>;
+    find(userContext: IUserContext, queryObject: IQueryOptions): Promise<T[]>;
+    findOne(userContext: IUserContext, queryObject: IQueryOptions): Promise<T | null>;
+}

package/dist/services/generic-api-service/generic-api.service.js

@@ -0,0 +1,178 @@
+import _ from 'lodash';
+import { DefaultQueryOptions } from '@loomcore/common/models';
+import { entityUtils } from '@loomcore/common/utils';
+import { stripSenderProvidedSystemProperties } from '../utils/strip-sender-provided-system-properties.util.js';
+import { auditForCreate } from '../utils/audit-for-create.util.js';
+import { auditForUpdate } from '../utils/audit-for-update.util.js';
+import { IdNotFoundError, ServerError } from '../../errors/index.js';
+export class GenericApiService {
+    database;
+    pluralResourceName;
+    singularResourceName;
+    modelSpec;
+    constructor(database, pluralResourceName, singularResourceName, modelSpec) {
+        this.pluralResourceName = pluralResourceName;
+        this.singularResourceName = singularResourceName;
+        this.modelSpec = modelSpec;
+        this.database = database;
+    }
+    async getAll(userContext) {
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const entities = await this.database.getAll(operations, this.pluralResourceName);
+        return entities.map(entity => this.postprocessEntity(userContext, entity));
+    }
+    prepareQuery(userContext, queryObject, operations) {
+        return { queryObject, operations };
+    }
+    validate(doc, isPartial = false) {
+        const validator = isPartial ? this.modelSpec.partialValidator : this.modelSpec.validator;
+        return entityUtils.validate(validator, doc);
+    }
+    validateMany(docs, isPartial = false) {
+        const validator = isPartial ? this.modelSpec.partialValidator : this.modelSpec.validator;
+        let allErrors = [];
+        for (const doc of docs) {
+            const errors = entityUtils.validate(validator, doc);
+            if (errors && errors.length > 0) {
+                allErrors.push(...errors);
+            }
+        }
+        return allErrors.length > 0 ? allErrors : null;
+    }
+    async preprocessEntity(userContext, entity, isCreate, allowId = true) {
+        let preparedEntity = _.clone(entity);
+        stripSenderProvidedSystemProperties(userContext, preparedEntity, allowId);
+        if (this.modelSpec.isAuditable) {
+            if (isCreate) {
+                auditForCreate(userContext, preparedEntity);
+            }
+            else {
+                auditForUpdate(userContext, preparedEntity);
+            }
+        }
+        if (!this.modelSpec?.fullSchema) {
+            throw new ServerError(`Cannot prepare entity: No model specification with schema provided for ${this.pluralResourceName}`);
+        }
+        let cleanedEntity = preparedEntity;
+        if (this.modelSpec) {
+            cleanedEntity = this.modelSpec.decode(preparedEntity);
+        }
+        preparedEntity = this.database.preprocessEntity(cleanedEntity, this.modelSpec.fullSchema);
+        return preparedEntity;
+    }
+    postprocessEntity(userContext, entity) {
+        return this.database.postprocessEntity(entity, this.modelSpec.fullSchema);
+    }
+    async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
+        const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const pagedResult = await this.database.get(operations, preparedOptions, this.modelSpec, this.pluralResourceName);
+        const transformedEntities = (pagedResult.entities || []).map(entity => this.postprocessEntity(userContext, entity));
+        return {
+            ...pagedResult,
+            entities: transformedEntities
+        };
+    }
+    prepareQueryOptions(userContext, queryOptions) {
+        return queryOptions;
+    }
+    async getById(userContext, id) {
+        const { operations, queryObject } = this.prepareQuery(userContext, {}, []);
+        const entity = await this.database.getById(operations, queryObject, id, this.pluralResourceName);
+        if (!entity) {
+            throw new IdNotFoundError();
+        }
+        return this.postprocessEntity(userContext, entity);
+    }
+    async getCount(userContext) {
+        this.prepareQuery(userContext, {}, []);
+        return await this.database.getCount(this.pluralResourceName);
+    }
+    async create(userContext, entity) {
+        let createdEntity = null;
+        const preparedEntity = await this.preprocessEntity(userContext, entity, true, true);
+        const insertResult = await this.database.create(preparedEntity, this.pluralResourceName);
+        if (insertResult.insertedId) {
+            createdEntity = this.postprocessEntity(userContext, insertResult.entity);
+        }
+        return createdEntity;
+    }
+    async createMany(userContext, entities) {
+        let createdEntities = [];
+        if (entities.length) {
+            const preparedEntities = await Promise.all(entities.map(entity => this.preprocessEntity(userContext, entity, true, true)));
+            const insertResult = await this.database.createMany(preparedEntities, this.pluralResourceName);
+            if (insertResult.insertedIds) {
+                createdEntities = insertResult.entities.map(entity => this.postprocessEntity(userContext, entity));
+            }
+        }
+        return createdEntities;
+    }
+    async batchUpdate(userContext, entities) {
+        if (!entities || entities.length === 0) {
+            return [];
+        }
+        const preparedEntities = await Promise.all(entities.map(entity => this.preprocessEntity(userContext, entity, false, true)));
+        const { queryObject, operations } = this.prepareQuery(userContext, {}, []);
+        const rawUpdatedEntities = await this.database.batchUpdate(preparedEntities, operations, queryObject, this.pluralResourceName);
+        const updatedEntities = rawUpdatedEntities.map(entity => this.postprocessEntity(userContext, entity));
+        return updatedEntities;
+    }
+    async fullUpdateById(userContext, id, entity) {
+        const { operations, queryObject } = this.prepareQuery(userContext, {}, []);
+        const existingEntity = await this.database.getById(operations, queryObject, id, this.pluralResourceName);
+        if (!existingEntity) {
+            throw new IdNotFoundError();
+        }
+        const auditProperties = {
+            _created: existingEntity._created,
+            _createdBy: existingEntity._createdBy,
+        };
+        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        Object.assign(preparedEntity, auditProperties);
+        const rawUpdatedEntity = await this.database.fullUpdateById(operations, id, preparedEntity, this.pluralResourceName);
+        const updatedEntity = this.postprocessEntity(userContext, rawUpdatedEntity);
+        return updatedEntity;
+    }
+    async partialUpdateById(userContext, id, entity) {
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        const rawUpdatedEntity = await this.database.partialUpdateById(operations, id, preparedEntity, this.pluralResourceName);
+        const updatedEntity = this.postprocessEntity(userContext, rawUpdatedEntity);
+        return updatedEntity;
+    }
+    async partialUpdateByIdWithoutPreAndPostProcessing(userContext, id, entity) {
+        const preparedEntity = this.database.preprocessEntity(entity, this.modelSpec.fullSchema);
+        const rawUpdatedEntity = await this.database.partialUpdateById([], id, preparedEntity, this.pluralResourceName);
+        return this.database.postprocessEntity(rawUpdatedEntity, this.modelSpec.fullSchema);
+    }
+    async update(userContext, queryObject, entity) {
+        const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
+        const preparedEntity = await this.preprocessEntity(userContext, entity, false, true);
+        const rawUpdatedEntities = await this.database.update(preparedQuery, preparedEntity, operations, this.pluralResourceName);
+        const updatedEntities = rawUpdatedEntities.map(entity => this.postprocessEntity(userContext, entity));
+        return updatedEntities;
+    }
+    async deleteById(userContext, id) {
+        const deleteResult = await this.database.deleteById(id, this.pluralResourceName);
+        if (deleteResult.count <= 0) {
+            throw new IdNotFoundError();
+        }
+        return deleteResult;
+    }
+    async deleteMany(userContext, queryObject) {
+        const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
+        const deleteResult = await this.database.deleteMany(preparedQuery, this.pluralResourceName);
+        return deleteResult;
+    }
+    async find(userContext, queryObject) {
+        const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
+        const rawEntities = await this.database.find(preparedQuery, this.pluralResourceName);
+        return rawEntities.map(entity => this.postprocessEntity(userContext, entity));
+    }
+    async findOne(userContext, queryObject) {
+        const { queryObject: preparedQuery, operations } = this.prepareQuery(userContext, queryObject, []);
+        const rawEntity = await this.database.findOne(preparedQuery, this.pluralResourceName);
+        return rawEntity ? this.postprocessEntity(userContext, rawEntity) : null;
+    }
+}

package/dist/services/index.d.ts

@@ -1,7 +1,7 @@
 export * from './auth.service.js';
 export * from './email.service.js';
-export * from './generic-api.service.js';
-export * from './generic-api-service.interface.js';
+export * from './generic-api-service/generic-api.service.js';
+export * from './generic-api-service/generic-api-service.interface.js';
 export * from './jwt.service.js';
 export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';

package/dist/services/index.js

@@ -1,7 +1,7 @@
 export * from './auth.service.js';
 export * from './email.service.js';
-export * from './generic-api.service.js';
-export * from './generic-api-service.interface.js';
+export * from './generic-api-service/generic-api.service.js';
+export * from './generic-api-service/generic-api-service.interface.js';
 export * from './jwt.service.js';
 export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';

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

@@ -1,10 +1,13 @@
-import { Db } from 'mongodb';
 import { IUserContext, IEntity, IQueryOptions, IModelSpec } from '@loomcore/common/models';
-import { GenericApiService } from './generic-api.service.js';
+import { Operation } from '../databases/operations/operation.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
+import { IDatabase } from '../databases/models/index.js';
 export declare class MultiTenantApiService<T extends IEntity> extends GenericApiService<T> {
     private tenantDecorator?;
-    constructor(db: Db, pluralResourceName: string, singularResourceName: string, modelSpec?: IModelSpec);
-    protected prepareQuery(userContext: IUserContext, query: any): any;
-    protected prepareQueryOptions(userContext: IUserContext, queryOptions: IQueryOptions): IQueryOptions;
-    protected prepareEntity(userContext: IUserContext, entity: T, isCreate: boolean, allowId?: boolean): Promise<T | Partial<T>>;
+    constructor(database: IDatabase, pluralResourceName: string, singularResourceName: string, modelSpec: IModelSpec);
+    prepareQuery(userContext: IUserContext, queryOptions: IQueryOptions, operations: Operation[]): {
+        queryObject: IQueryOptions;
+        operations: Operation[];
+    };
+    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
 }

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

@@ -1,46 +1,33 @@
-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';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 export class MultiTenantApiService extends GenericApiService {
     tenantDecorator;
-    constructor(db, pluralResourceName, singularResourceName, modelSpec) {
-        super(db, pluralResourceName, singularResourceName, modelSpec);
+    constructor(database, pluralResourceName, singularResourceName, modelSpec) {
+        super(database, pluralResourceName, singularResourceName, modelSpec);
         if (config?.app?.isMultiTenant) {
             this.tenantDecorator = new TenantQueryDecorator();
         }
     }
-    prepareQuery(userContext, query) {
+    prepareQuery(userContext, queryOptions, operations) {
         if (!config?.app?.isMultiTenant) {
-            return super.prepareQuery(userContext, query);
+            return super.prepareQuery(userContext, queryOptions, operations);
         }
         if (!userContext || !userContext._orgId) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQuery');
         }
-        return this.tenantDecorator.applyTenantToQuery(userContext, query, this.pluralResourceName);
+        const queryObject = this.tenantDecorator.applyTenantToQuery(userContext, queryOptions, this.pluralResourceName);
+        return { queryObject, operations };
     }
-    prepareQueryOptions(userContext, queryOptions) {
-        console.log('--- MultiTenantApiService.prepareQueryOptions ---');
-        console.log('Initial queryOptions.filters:', JSON.stringify(queryOptions.filters, null, 2));
+    async preprocessEntity(userContext, entity, isCreate, allowId = false) {
         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');
-        }
-        const newQueryOptions = this.tenantDecorator.applyTenantToQueryOptions(userContext, queryOptions, this.pluralResourceName);
-        console.log('Final queryOptions.filters:', JSON.stringify(newQueryOptions.filters, null, 2));
-        console.log('-------------------------------------------------');
-        return newQueryOptions;
-    }
-    async prepareEntity(userContext, entity, isCreate, allowId = false) {
-        if (!config?.app?.isMultiTenant) {
-            return super.prepareEntity(userContext, entity, isCreate, allowId);
+            return super.preprocessEntity(userContext, entity, isCreate, allowId);
         }
         if (!userContext || !userContext._orgId) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
         }
-        const preparedEntity = await super.prepareEntity(userContext, entity, isCreate, allowId);
+        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
         const orgIdField = this.tenantDecorator.getOrgIdField();
         preparedEntity[orgIdField] = userContext._orgId;
         return preparedEntity;

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

@@ -1,9 +1,9 @@
-import { Db } from 'mongodb';
-import { GenericApiService } from './generic-api.service.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 import { IOrganization, IUserContext } from '@loomcore/common/models';
+import { IDatabase } from '../databases/models/database.interface.js';
 export declare class OrganizationService extends GenericApiService<IOrganization> {
-    constructor(db: Db);
-    getAuthTokenByRepoCode(userContext: IUserContext, orgId: string): Promise<string | null | undefined>;
+    constructor(database: IDatabase);
+    getAuthTokenByRepoCode(userContext: IUserContext, orgId: string): Promise<string | null>;
     validateRepoAuthToken(userContext: IUserContext, orgCode: string, authToken: string): Promise<string | null>;
-    getMetaOrg(userContext: IUserContext): Promise<IOrganization>;
+    getMetaOrg(userContext: IUserContext): Promise<IOrganization | null>;
 }