@loomcore/api 0.0.1

package/dist/errors/not-found.error.js

@@ -0,0 +1,12 @@
+import { CustomError } from '@loomcore/common/errors';
+export class NotFoundError extends CustomError {
+    statusCode = 404;
+    constructor(message) {
+        const errorMessage = message ? message : 'Not Found';
+        super(errorMessage);
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}

package/dist/errors/server.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class ServerError extends CustomError {
+    statusCode: number;
+    constructor(message: string);
+    serializeErrors(): {
+        message: string;
+        field?: string | undefined;
+    }[];
+}

package/dist/errors/server.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '@loomcore/common/errors';
+export class ServerError extends CustomError {
+    statusCode = 500;
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ServerError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}

package/dist/errors/unauthenticated.error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class UnauthenticatedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/dist/errors/unauthenticated.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '@loomcore/common/errors';
+export class UnauthenticatedError extends CustomError {
+    statusCode = 401;
+    constructor() {
+        super('Unauthenticated');
+        Object.setPrototypeOf(this, UnauthenticatedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: 'Unauthenticated' }];
+    }
+}

package/dist/errors/unauthorized.error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class UnauthorizedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/dist/errors/unauthorized.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '@loomcore/common/errors';
+export class UnauthorizedError extends CustomError {
+    statusCode = 403;
+    constructor() {
+        super('Unauthorized');
+        Object.setPrototypeOf(this, UnauthorizedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: 'Unauthorized' }];
+    }
+}

package/dist/middleware/ensure-user-context.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const ensureUserContext: (req: Request, res: Response, next: NextFunction) => void;

package/dist/middleware/ensure-user-context.js

@@ -0,0 +1,7 @@
+import { EmptyUserContext } from '@loomcore/common/models';
+export const ensureUserContext = (req, res, next) => {
+    if (!req.userContext) {
+        req.userContext = EmptyUserContext;
+    }
+    next();
+};

package/dist/middleware/error-handler.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => void;

package/dist/middleware/error-handler.js

@@ -0,0 +1,30 @@
+import { CustomError } from '@loomcore/common/errors';
+import { apiUtils } from '../utils/index.js';
+import { config } from '../config/api-common-config.js';
+export const errorHandler = (err, req, res, next) => {
+    if (config.debug?.showErrors || config.env !== 'test') {
+        console.error('API Error:', {
+            error: err.message,
+            stack: err.stack,
+            path: req.path,
+            method: req.method,
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            timestamp: new Date().toISOString(),
+            errorType: err.constructor.name,
+            isCustomError: err instanceof CustomError,
+            headers: req.headers
+        });
+    }
+    if (err instanceof CustomError) {
+        apiUtils.apiResponse(res, err.statusCode, {
+            errors: err.serializeErrors()
+        });
+    }
+    else {
+        apiUtils.apiResponse(res, 500, {
+            errors: [{ message: 'Server Error' }]
+        });
+    }
+};

package/dist/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error-handler.js';
+export * from './is-authenticated.js';
+export * from './ensure-user-context.js';

package/dist/middleware/index.js

@@ -0,0 +1,3 @@
+export * from './error-handler.js';
+export * from './is-authenticated.js';
+export * from './ensure-user-context.js';

package/dist/middleware/is-authenticated.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const isAuthenticated: (req: Request, res: Response, next: NextFunction) => void;

package/dist/middleware/is-authenticated.js

@@ -0,0 +1,27 @@
+import { UserContextSpec } from '@loomcore/common/models';
+import { UnauthenticatedError } from '../errors/index.js';
+import { JwtService } from '../services/index.js';
+import { config } from '../config/index.js';
+export const isAuthenticated = (req, res, next) => {
+    let token = null;
+    if (req.headers?.authorization) {
+        let authHeader = req.headers.authorization;
+        const authHeaderArray = authHeader.split('Bearer ');
+        if (authHeaderArray?.length > 1) {
+            token = authHeaderArray[1];
+        }
+    }
+    if (token) {
+        try {
+            const rawPayload = JwtService.verify(token, config.clientSecret);
+            req.userContext = UserContextSpec.decode(rawPayload);
+            next();
+        }
+        catch (err) {
+            throw new UnauthenticatedError();
+        }
+    }
+    else {
+        throw new UnauthenticatedError();
+    }
+};

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

@@ -0,0 +1,22 @@
+export interface IApiCommonConfig {
+    env: string;
+    hostName: string;
+    appName: string;
+    clientSecret: string;
+    debug?: {
+        showErrors?: boolean;
+    };
+    app: {
+        multiTenant: boolean;
+    };
+    auth: {
+        jwtExpirationInSeconds: number;
+        refreshTokenExpirationInDays: number;
+        deviceIdCookieMaxAgeInDays: number;
+        passwordResetTokenExpirationInMinutes: number;
+    };
+    email: {
+        sendGridApiKey?: string;
+        fromAddress?: string;
+    };
+}

package/dist/models/api-common-config.interface.js

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

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

@@ -0,0 +1,12 @@
+import { IApiCommonConfig } from './api-common-config.interface.js';
+export interface IBaseApiConfig {
+    mongoDbUrl?: string;
+    databaseName?: string;
+    externalPort?: number;
+    internalPort?: number;
+    corsAllowedOrigins: string[];
+    saltWorkFactor?: number;
+    jobTypes?: string;
+    deployedBranch?: string;
+    api: IApiCommonConfig;
+}

package/dist/models/base-api-config.interface.js

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

package/dist/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api-common-config.interface.js';
+export * from './base-api-config.interface.js';
+export * from './types/index.js';

package/dist/models/index.js

@@ -0,0 +1,3 @@
+export * from './api-common-config.interface.js';
+export * from './base-api-config.interface.js';
+export * from './types/index.js';

package/dist/models/types/index.d.ts

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

package/dist/models/types/index.js

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

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

@@ -0,0 +1,54 @@
+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';
+export declare class AuthService extends GenericApiService<IUser> {
+    private refreshTokensCollection;
+    private passwordResetTokenService;
+    private emailService;
+    constructor(db: Db);
+    attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
+    logUserIn(userContext: IUserContext, deviceId: string): Promise<{
+        tokens: {
+            accessToken: string;
+            refreshToken: string;
+            expiresOn: number;
+        };
+        userContext: IUserContext;
+    } | null>;
+    getUserById(id: string): Promise<import("mongodb").WithId<import("bson").Document> | null>;
+    getUserByEmail(email: string): Promise<IUser>;
+    createUser(userContext: IUserContext, user: IUser): Promise<IUser | null>;
+    requestTokenUsingRefreshToken(req: Request): Promise<ITokenResponse | null>;
+    changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult<import("bson").Document>>;
+    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>;
+    sendResetPasswordEmail(emailAddress: string): Promise<void>;
+    resetPassword(email: string, passwordResetToken: string, password: string): Promise<UpdateResult>;
+    deleteRefreshTokensForDevice(deviceId: string): Promise<import("mongodb").DeleteResult>;
+    generateJwt(payload: any): string;
+    generateRefreshToken(): string;
+    generateDeviceId(): string;
+    getAndSetDeviceIdCookie(req: Request, res: Response): string;
+    getDeviceIdFromCookie(req: Request): any;
+    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;
+    private updateLastLoggedIn;
+}

package/dist/services/auth.service.js

@@ -0,0 +1,283 @@
+import { ObjectId } from 'mongodb';
+import moment from 'moment';
+import crypto from 'crypto';
+import { EmptyUserContext, passwordValidator, UserSpec } 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 { PasswordResetTokenService } from './password-reset-token.service.js';
+import { passwordUtils } from '../utils/index.js';
+import { config } from '../config/index.js';
+export class AuthService extends GenericApiService {
+    refreshTokensCollection;
+    passwordResetTokenService;
+    emailService;
+    constructor(db) {
+        super(db, 'users', 'user', UserSpec);
+        this.refreshTokensCollection = db.collection('refreshTokens');
+        this.passwordResetTokenService = new PasswordResetTokenService(db);
+        this.emailService = new EmailService();
+    }
+    async attemptLogin(req, res, email, password) {
+        const lowerCaseEmail = email.toLowerCase();
+        const user = await this.getUserByEmail(lowerCaseEmail);
+        if (!user) {
+            throw new BadRequestError('Invalid Credentials');
+        }
+        const passwordsMatch = await passwordUtils.comparePasswords(user.password, password);
+        if (!passwordsMatch) {
+            throw new BadRequestError('Invalid Credentials');
+        }
+        const userContext = {
+            user: user,
+            _orgId: user._orgId
+        };
+        const deviceId = this.getAndSetDeviceIdCookie(req, res);
+        const loginResponse = await this.logUserIn(userContext, deviceId);
+        return loginResponse;
+    }
+    async logUserIn(userContext, deviceId) {
+        const payload = userContext;
+        const accessToken = this.generateJwt(payload);
+        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id.toString(), deviceId);
+        const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
+        let loginResponse = null;
+        if (refreshTokenObject) {
+            const tokenResponse = {
+                accessToken,
+                refreshToken: refreshTokenObject.token,
+                expiresOn: accessTokenExpiresOn
+            };
+            this.updateLastLoggedIn(userContext.user._id.toString())
+                .catch(err => console.log(`Error updating lastLoggedIn: ${err}`));
+            this.transformSingle(userContext.user);
+            loginResponse = { tokens: tokenResponse, userContext };
+        }
+        return loginResponse;
+    }
+    getUserById(id) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        return this.collection.findOne({ _id: new ObjectId(id) })
+            .then((doc) => {
+            return doc;
+        });
+    }
+    getUserByEmail(email) {
+        return this.collection.findOne({ email: email })
+            .then((user) => {
+            return user;
+        });
+    }
+    async createUser(userContext, user) {
+        const createdUser = await this.create(userContext, user);
+        return createdUser;
+    }
+    async requestTokenUsingRefreshToken(req) {
+        const refreshToken = req.query.refreshToken;
+        const deviceId = this.getDeviceIdFromCookie(req);
+        let tokens = null;
+        if (refreshToken && typeof refreshToken === 'string' && deviceId) {
+            let userId = null;
+            const activeRefreshToken = await this.getActiveRefreshToken(refreshToken, deviceId);
+            if (activeRefreshToken) {
+                userId = activeRefreshToken.userId;
+                if (userId) {
+                    tokens = await this.createNewTokens(userId, deviceId, activeRefreshToken.expiresOn);
+                }
+            }
+        }
+        return tokens;
+    }
+    async changeLoggedInUsersPassword(userContext, body) {
+        const validationResult = entityUtils.validate(passwordValidator, { password: body.password });
+        entityUtils.handleValidationResult(validationResult, 'AuthService.changePassword');
+        const queryObject = { _id: new ObjectId(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);
+        let updates = { password: hashedPassword, lastPasswordChange: moment().utc().toDate() };
+        updates = (await this.onBeforeUpdate(userContext, updates));
+        const mongoUpdateResult = await this.collection.updateOne(queryObject, { $set: updates });
+        if (mongoUpdateResult?.modifiedCount > 0) {
+            await this.onAfterUpdate(userContext, updates);
+        }
+        return mongoUpdateResult;
+    }
+    async createNewTokens(userId, deviceId, refreshTokenExpiresOn) {
+        let createdRefreshTokenObject = null;
+        const newRefreshToken = await this.createNewRefreshToken(userId, deviceId, refreshTokenExpiresOn);
+        let user = null;
+        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
+            };
+            const accessToken = this.generateJwt(payload);
+            const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
+            tokenResponse = {
+                accessToken,
+                refreshToken: createdRefreshTokenObject.token,
+                expiresOn: accessTokenExpiresOn
+            };
+        }
+        return tokenResponse;
+    }
+    async getActiveRefreshToken(refreshToken, deviceId) {
+        const refreshTokenResult = await this.refreshTokensCollection.findOne({ token: refreshToken, deviceId: deviceId });
+        let activeRefreshToken = null;
+        if (refreshTokenResult) {
+            const now = Date.now();
+            const notExpired = refreshTokenResult.expiresOn > now;
+            if (notExpired) {
+                activeRefreshToken = refreshTokenResult;
+            }
+        }
+        return activeRefreshToken;
+    }
+    async createNewRefreshToken(userId, deviceId, existingExpiresOn = null) {
+        const expiresOn = existingExpiresOn ? existingExpiresOn : this.getExpiresOnFromDays(config.auth.refreshTokenExpirationInDays);
+        const newRefreshToken = {
+            token: this.generateRefreshToken(),
+            deviceId,
+            userId,
+            expiresOn: expiresOn,
+            created: moment().utc().toDate(),
+            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;
+    }
+    async sendResetPasswordEmail(emailAddress) {
+        const expiresOn = this.getExpiresOnFromMinutes(config.auth.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 htmlEmailBody = `<strong><a href="${resetPasswordLink}">Reset Password</a></strong>`;
+        await this.emailService.sendHtmlEmail(emailAddress, `Reset Password for ${config.appName}`, htmlEmailBody);
+    }
+    async resetPassword(email, passwordResetToken, password) {
+        const retrievedPasswordResetToken = await this.passwordResetTokenService.getByEmail(email);
+        if (!retrievedPasswordResetToken) {
+            throw new ServerError(`Unable to retrieve password reset token for email: ${email}`);
+        }
+        if (retrievedPasswordResetToken.token !== passwordResetToken || retrievedPasswordResetToken.expiresOn < Date.now()) {
+            throw new BadRequestError('Invalid password reset token');
+        }
+        const result = await this.changePassword(EmptyUserContext, { email }, password);
+        console.log(`password changed using forgot-password for email: ${email}`);
+        await this.passwordResetTokenService.deleteById(EmptyUserContext, retrievedPasswordResetToken._id.toString());
+        console.log(`passwordResetToken deleted for email: ${email}`);
+        return result;
+    }
+    deleteRefreshTokensForDevice(deviceId) {
+        return this.refreshTokensCollection.deleteMany({ deviceId: deviceId });
+    }
+    generateJwt(payload) {
+        if (payload._orgId !== undefined) {
+            payload._orgId = String(payload._orgId);
+        }
+        const jwtExpiryConfig = config.auth.jwtExpirationInSeconds;
+        const jwtExpirationInSeconds = (typeof jwtExpiryConfig === 'string') ? parseInt(jwtExpiryConfig) : jwtExpiryConfig;
+        const accessToken = JwtService.sign(payload, config.clientSecret, {
+            expiresIn: jwtExpirationInSeconds
+        });
+        return accessToken;
+    }
+    ;
+    generateRefreshToken() {
+        return crypto.randomBytes(40).toString('hex');
+    }
+    generateDeviceId() {
+        return crypto.randomBytes(40).toString('hex');
+    }
+    getAndSetDeviceIdCookie(req, res) {
+        let isNewDeviceId = false;
+        let deviceId = '';
+        const deviceIdFromCookie = this.getDeviceIdFromCookie(req);
+        if (deviceIdFromCookie) {
+            deviceId = deviceIdFromCookie;
+        }
+        else {
+            deviceId = this.generateDeviceId();
+            isNewDeviceId = true;
+        }
+        if (isNewDeviceId) {
+            const cookieOptions = {
+                maxAge: config.auth.deviceIdCookieMaxAgeInDays * 24 * 60 * 60 * 1000,
+                httpOnly: true
+            };
+            if (config.env === 'local' || config.env === 'dev') {
+                console.log('setting deviceId cookieOptions sameSite=none and secure=true');
+                cookieOptions['sameSite'] = 'none';
+                cookieOptions['secure'] = true;
+            }
+            res.cookie('deviceId', deviceId, cookieOptions);
+        }
+        return deviceId;
+    }
+    getDeviceIdFromCookie(req) {
+        return req.cookies['deviceId'];
+    }
+    getExpiresOnFromSeconds(expiresInSeconds) {
+        return Date.now() + expiresInSeconds * 1000;
+    }
+    getExpiresOnFromMinutes(expiresInMinutes) {
+        return Date.now() + expiresInMinutes * 60 * 1000;
+    }
+    getExpiresOnFromDays(expiresInDays) {
+        return Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
+    }
+    async prepareEntity(userContext, entity, isCreate) {
+        if (entity.email) {
+            entity.email = entity.email.toLowerCase();
+        }
+        if (entity.password) {
+            const hash = await passwordUtils.hashPassword(entity.password);
+            entity.password = hash;
+        }
+        if (isCreate && !entity.roles) {
+            entity.roles = ["user"];
+        }
+        const preparedEntity = await super.prepareEntity(userContext, entity, isCreate);
+        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 queryObject = { _id: new ObjectId(userId) };
+            const updates = { lastLoggedIn: moment().utc().toDate() };
+            await this.collection.updateOne(queryObject, { $set: updates });
+        }
+        catch (error) {
+            console.log(`Failed to update lastLoggedIn for user ${userId}: ${error}`);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class EmailService {
+    constructor();
+    sendHtmlEmail(emailAddress: string, subject: string, body: string): Promise<void>;
+}

package/dist/services/email.service.js

@@ -0,0 +1,24 @@
+import sgMail from '@sendgrid/mail';
+import { ServerError } from '../errors/index.js';
+import { config } from '../config/index.js';
+export class EmailService {
+    constructor() {
+        sgMail.setApiKey(config.email.sendGridApiKey);
+    }
+    async sendHtmlEmail(emailAddress, subject, body) {
+        const msg = {
+            to: emailAddress,
+            from: config.email.fromAddress,
+            subject: subject,
+            html: `${body}`,
+        };
+        try {
+            await sgMail.send(msg);
+            console.log(`Email sent to ${emailAddress} with subject ${subject}`);
+        }
+        catch (error) {
+            console.error('Error sending email:', error);
+            throw new ServerError('Error sending email');
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { DeleteResult, Document, FindOptions } from 'mongodb';
+import { IUserContext, IEntity, IPagedResult, QueryOptions } from '@loomcore/common/models';
+export interface IGenericApiService<T extends IEntity> {
+    getAll(userContext: IUserContext): Promise<T[]>;
+    get(userContext: IUserContext, queryOptions: QueryOptions): Promise<IPagedResult<T>>;
+    getById(userContext: IUserContext, id: string): Promise<T>;
+    getCount(userContext: IUserContext): Promise<number>;
+    create(userContext: IUserContext, item: T): Promise<T | null>;
+    createMany(userContext: IUserContext, items: T[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, item: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, item: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, item: Partial<T>): Promise<T>;
+    update(userContext: IUserContext, queryObject: any, item: Partial<T>): Promise<T[]>;
+    deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
+    deleteMany(userContext: IUserContext, queryObject: any): Promise<DeleteResult>;
+    find(userContext: IUserContext, mongoQueryObject: any, options?: FindOptions<Document> | undefined): Promise<T[]>;
+    findOne(userContext: IUserContext, mongoQueryObject: any, options?: FindOptions<Document> | undefined): Promise<T>;
+}

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

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