@loomcore/api 0.0.1

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

@@ -0,0 +1,44 @@
+import { Db, Collection, DeleteResult, Document, FindOptions } from 'mongodb';
+import { ValueError } from '@sinclair/typebox/errors';
+import { IUserContext, IEntity, QueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import { IGenericApiService } from './generic-api-service.interface.js';
+export declare class GenericApiService<T extends IEntity> implements IGenericApiService<T> {
+    protected db: Db;
+    protected pluralResourceName: string;
+    protected singularResourceName: string;
+    protected collection: Collection;
+    protected modelSpec?: IModelSpec;
+    constructor(db: Db, pluralResourceName: string, singularResourceName: string, modelSpec?: IModelSpec);
+    validate(doc: any, isPartial?: boolean): ValueError[] | null;
+    protected getAdditionalPipelineStages(): any[];
+    protected createAggregationPipeline(userContext: IUserContext, query: any, queryOptions?: QueryOptions): any[];
+    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, entity: T | Partial<T>): Promise<T | null>;
+    createMany(userContext: IUserContext, entities: T[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    update(userContext: IUserContext, queryObject: any, entity: 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>;
+    auditForCreate(userContext: IUserContext, doc: any): void;
+    auditForUpdate(userContext: IUserContext, doc: any): void;
+    onBeforeCreate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
+    onAfterCreate<E extends T | T[]>(userContext: IUserContext | undefined, entities: E): Promise<E | E[]>;
+    onBeforeUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
+    onAfterUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext | undefined, entities: E): Promise<E>;
+    onBeforeDelete(userContext: IUserContext, queryObject: any): Promise<any>;
+    onAfterDelete(userContext: IUserContext, queryObject: any): Promise<any>;
+    transformList(list: any[]): T[];
+    transformSingle(single: any): T;
+    private stripSenderProvidedSystemProperties;
+    protected preparePayload<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entity: E, isCreate?: boolean): Promise<E | E[]>;
+    protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean): Promise<T | Partial<T>>;
+    protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
+    protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: QueryOptions): QueryOptions;
+}

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

@@ -0,0 +1,378 @@
+import { ObjectId } from 'mongodb';
+import moment from 'moment';
+import _ from 'lodash';
+import { QueryOptions } from '@loomcore/common/models';
+import { entityUtils } from '@loomcore/common/utils';
+import { BadRequestError, DuplicateKeyError, IdNotFoundError, NotFoundError, ServerError } from '../errors/index.js';
+import { apiUtils, dbUtils } from '../utils/index.js';
+export class GenericApiService {
+    db;
+    pluralResourceName;
+    singularResourceName;
+    collection;
+    modelSpec;
+    constructor(db, pluralResourceName, singularResourceName, modelSpec) {
+        this.db = db;
+        this.pluralResourceName = pluralResourceName;
+        this.singularResourceName = singularResourceName;
+        this.collection = db.collection(pluralResourceName);
+        this.modelSpec = modelSpec;
+    }
+    validate(doc, isPartial = false) {
+        if (!this.modelSpec) {
+            return null;
+        }
+        const validator = isPartial ? this.modelSpec.partialValidator : this.modelSpec.validator;
+        return entityUtils.validate(validator, doc);
+    }
+    getAdditionalPipelineStages() {
+        return [];
+    }
+    createAggregationPipeline(userContext, query, queryOptions) {
+        const match = { $match: query };
+        const additionalStages = this.getAdditionalPipelineStages();
+        let resultStages = [...additionalStages];
+        if (queryOptions) {
+            if (queryOptions.orderBy) {
+                resultStages.push({
+                    $sort: {
+                        [queryOptions.orderBy]: queryOptions.sortDirection === 'asc' ? 1 : -1
+                    }
+                });
+            }
+            if (queryOptions.page && queryOptions.pageSize) {
+                resultStages.push({ $skip: (queryOptions.page - 1) * queryOptions.pageSize });
+                resultStages.push({ $limit: queryOptions.pageSize });
+            }
+        }
+        return [match, ...resultStages];
+    }
+    async getAll(userContext) {
+        const query = this.prepareQuery(userContext, {});
+        let entities = [];
+        if (this.getAdditionalPipelineStages().length > 0) {
+            const pipeline = this.createAggregationPipeline(userContext, query);
+            entities = await this.collection.aggregate(pipeline).toArray();
+        }
+        else {
+            const cursor = this.collection.find(query);
+            entities = await cursor.toArray();
+        }
+        return this.transformList(entities);
+    }
+    async get(userContext, queryOptions = new QueryOptions()) {
+        const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
+        const match = dbUtils.buildMongoMatchFromQueryOptions(preparedOptions);
+        const additionalStages = this.getAdditionalPipelineStages();
+        const results = [...additionalStages];
+        if (preparedOptions.orderBy) {
+            results.push({ $sort: { [preparedOptions.orderBy]: preparedOptions.sortDirection === 'asc' ? 1 : -1 } });
+        }
+        if (preparedOptions.page && preparedOptions.pageSize) {
+            results.push({ $skip: (preparedOptions.page - 1) * preparedOptions.pageSize });
+            results.push({ $limit: preparedOptions.pageSize });
+        }
+        const pipeline = [
+            match,
+            {
+                $facet: {
+                    results: results,
+                    total: [
+                        { $count: 'total' }
+                    ]
+                }
+            }
+        ];
+        let pagedResult = apiUtils.getPagedResult([], 0, preparedOptions);
+        const cursor = this.collection.aggregate(pipeline);
+        const aggregateResult = await cursor.next();
+        if (aggregateResult) {
+            let total = 0;
+            if (aggregateResult.total && aggregateResult.total.length > 0) {
+                total = aggregateResult.total[0].total;
+            }
+            const entities = this.transformList(aggregateResult.results);
+            pagedResult = apiUtils.getPagedResult(entities, total, preparedOptions);
+        }
+        return pagedResult;
+    }
+    async getById(userContext, id) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        const baseQuery = { _id: new ObjectId(id) };
+        const query = this.prepareQuery(userContext, baseQuery);
+        let entity = null;
+        if (this.getAdditionalPipelineStages().length > 0) {
+            const pipeline = this.createAggregationPipeline(userContext, query);
+            entity = await this.collection.aggregate(pipeline).next();
+        }
+        else {
+            entity = await this.collection.findOne(query);
+        }
+        if (!entity) {
+            throw new IdNotFoundError();
+        }
+        return this.transformSingle(entity);
+    }
+    async getCount(userContext) {
+        const query = this.prepareQuery(userContext, {});
+        const count = await this.collection.countDocuments(query);
+        return count;
+    }
+    async create(userContext, entity) {
+        const validationErrors = this.validate(entity);
+        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.create');
+        let createdEntity = null;
+        try {
+            const preparedEntity = await this.onBeforeCreate(userContext, entity);
+            const insertResult = await this.collection.insertOne(preparedEntity);
+            if (insertResult.insertedId) {
+                createdEntity = this.transformSingle(preparedEntity);
+            }
+            if (createdEntity) {
+                await this.onAfterCreate(userContext, createdEntity);
+            }
+        }
+        catch (err) {
+            if (err.code === 11000) {
+                throw new DuplicateKeyError(`${this.singularResourceName} already exists`);
+            }
+            throw new BadRequestError(`Error creating ${this.singularResourceName}`);
+        }
+        return createdEntity;
+    }
+    async createMany(userContext, entities) {
+        let createdEntities = [];
+        if (entities.length) {
+            try {
+                for (const entity of entities) {
+                    const validationErrors = this.validate(entity);
+                    entityUtils.handleValidationResult(validationErrors, 'GenericApiService.createMany');
+                }
+                const preparedEntities = await this.onBeforeCreate(userContext, entities);
+                const insertResult = await this.collection.insertMany(preparedEntities);
+                if (insertResult.insertedIds) {
+                    createdEntities = this.transformList(preparedEntities);
+                }
+                await this.onAfterCreate(userContext, createdEntities);
+            }
+            catch (err) {
+                if (err.code === 11000) {
+                    throw new DuplicateKeyError(`One or more ${this.pluralResourceName} already exist`);
+                }
+                throw new BadRequestError(`Error creating ${this.pluralResourceName}`);
+            }
+        }
+        return createdEntities;
+    }
+    async fullUpdateById(userContext, id, entity) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        const validationErrors = this.validate(entity);
+        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.fullUpdateById');
+        const baseQuery = { _id: new ObjectId(id) };
+        const query = this.prepareQuery(userContext, baseQuery);
+        const existingEntity = await this.collection.findOne(query);
+        if (!existingEntity) {
+            throw new IdNotFoundError();
+        }
+        const auditProperties = {
+            _created: existingEntity._created,
+            _createdBy: existingEntity._createdBy,
+        };
+        const clone = await this.onBeforeUpdate(userContext, entity);
+        Object.assign(clone, auditProperties);
+        const mongoUpdateResult = await this.collection.replaceOne(query, clone);
+        if (mongoUpdateResult?.matchedCount <= 0) {
+            throw new IdNotFoundError();
+        }
+        await this.onAfterUpdate(userContext, clone);
+        const updatedEntity = await this.collection.findOne(query);
+        return this.transformSingle(updatedEntity);
+    }
+    async partialUpdateById(userContext, id, entity) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        const validationErrors = this.validate(entity, true);
+        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateById');
+        const clone = await this.onBeforeUpdate(userContext, entity);
+        const baseQuery = { _id: new ObjectId(id) };
+        const query = this.prepareQuery(userContext, baseQuery);
+        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: clone }, { returnDocument: 'after' });
+        if (!updatedEntity) {
+            throw new IdNotFoundError();
+        }
+        else {
+            const typedEntity = updatedEntity;
+            await this.onAfterUpdate(userContext, typedEntity);
+        }
+        return this.transformSingle(updatedEntity);
+    }
+    async partialUpdateByIdWithoutBeforeAndAfter(userContext, id, entity) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        const validationErrors = this.validate(entity, true);
+        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateByIdWithoutBeforeAndAfter');
+        const preparedEntity = this.preparePayload(userContext, entity, false);
+        const baseQuery = { _id: new ObjectId(id) };
+        const query = this.prepareQuery(userContext, baseQuery);
+        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
+        let updatedEntity = null;
+        if (modifyResult?.ok === 1) {
+            updatedEntity = modifyResult.value;
+        }
+        else {
+            if (!modifyResult?.value) {
+                throw new IdNotFoundError();
+            }
+            else {
+                throw new ServerError(`Error updating ${this.singularResourceName} - ${JSON.stringify(modifyResult.lastErrorObject)}`);
+            }
+        }
+        return this.transformSingle(updatedEntity);
+    }
+    async update(userContext, queryObject, entity) {
+        const clone = await this.onBeforeUpdate(userContext, entity);
+        const query = this.prepareQuery(userContext, queryObject);
+        const mongoUpdateResult = await this.collection.updateMany(query, { $set: clone });
+        if (mongoUpdateResult?.matchedCount <= 0) {
+            throw new NotFoundError('No records found matching update query');
+        }
+        await this.onAfterUpdate(userContext, clone);
+        const updatedEntities = await this.collection.find(query).toArray();
+        return this.transformList(updatedEntities);
+    }
+    async deleteById(userContext, id) {
+        if (!entityUtils.isValidObjectId(id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        const baseQuery = { _id: new ObjectId(id) };
+        const query = this.prepareQuery(userContext, baseQuery);
+        await this.onBeforeDelete(userContext, query);
+        const deleteResult = await this.collection.deleteOne(query);
+        if (deleteResult.deletedCount <= 0) {
+            throw new IdNotFoundError();
+        }
+        await this.onAfterDelete(userContext, query);
+        return deleteResult;
+    }
+    async deleteMany(userContext, queryObject) {
+        const query = this.prepareQuery(userContext, queryObject);
+        await this.onBeforeDelete(userContext, query);
+        const deleteResult = await this.collection.deleteMany(query);
+        await this.onAfterDelete(userContext, query);
+        return deleteResult;
+    }
+    async find(userContext, mongoQueryObject, options) {
+        const query = this.prepareQuery(userContext, mongoQueryObject);
+        const cursor = this.collection.find(query, options);
+        const entities = await cursor.toArray();
+        return this.transformList(entities);
+    }
+    async findOne(userContext, mongoQueryObject, options) {
+        const query = this.prepareQuery(userContext, mongoQueryObject);
+        const entity = await this.collection.findOne(query, options);
+        return this.transformSingle(entity);
+    }
+    auditForCreate(userContext, doc) {
+        const now = moment().utc().toDate();
+        const userId = userContext.user?._id?.toString() ?? 'system';
+        doc._created = now;
+        doc._createdBy = userId;
+        doc._updated = now;
+        doc._updatedBy = userId;
+    }
+    auditForUpdate(userContext, doc) {
+        const userId = userContext.user?._id?.toString() ?? 'system';
+        doc._updated = moment().utc().toDate();
+        doc._updatedBy = userId;
+    }
+    async onBeforeCreate(userContext, entities) {
+        const preparedEntities = await this.preparePayload(userContext, entities, true);
+        return Promise.resolve(preparedEntities);
+    }
+    async onAfterCreate(userContext, entities) {
+        return Promise.resolve(entities);
+    }
+    async onBeforeUpdate(userContext, entities) {
+        const preparedEntities = await this.preparePayload(userContext, entities, false);
+        return Promise.resolve(preparedEntities);
+    }
+    onAfterUpdate(userContext, entities) {
+        return Promise.resolve(entities);
+    }
+    onBeforeDelete(userContext, queryObject) {
+        return Promise.resolve(queryObject);
+    }
+    onAfterDelete(userContext, queryObject) {
+        return Promise.resolve(queryObject);
+    }
+    transformList(list) {
+        if (!list)
+            return [];
+        return list.map(item => this.transformSingle(item));
+    }
+    transformSingle(single) {
+        if (!single)
+            return single;
+        if (!this.modelSpec?.fullSchema) {
+            throw new ServerError(`Cannot transform entity: No model specification with schema provided for ${this.pluralResourceName}`);
+        }
+        const transformedEntity = dbUtils.convertObjectIdsToStrings(single, this.modelSpec.fullSchema);
+        return transformedEntity;
+    }
+    stripSenderProvidedSystemProperties(doc) {
+        if (doc._created) {
+            delete doc._created;
+        }
+        if (doc._createdBy) {
+            delete doc._createdBy;
+        }
+        if (doc._updated) {
+            delete doc._updated;
+        }
+        if (doc._updatedBy) {
+            delete doc._updatedBy;
+        }
+    }
+    async preparePayload(userContext, entity, isCreate = false) {
+        let result;
+        if (Array.isArray(entity)) {
+            result = await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
+        }
+        else {
+            result = await this.prepareEntity(userContext, entity, isCreate);
+        }
+        return result;
+    }
+    async prepareEntity(userContext, entity, isCreate) {
+        const preparedEntity = _.clone(entity);
+        this.stripSenderProvidedSystemProperties(preparedEntity);
+        if (this.modelSpec?.isAuditable) {
+            if (isCreate) {
+                this.auditForCreate(userContext, preparedEntity);
+            }
+            else {
+                this.auditForUpdate(userContext, preparedEntity);
+            }
+        }
+        let cleanedEntity = preparedEntity;
+        if (this.modelSpec) {
+            cleanedEntity = this.modelSpec.decode(preparedEntity);
+        }
+        if (!this.modelSpec?.fullSchema) {
+            throw new ServerError(`Cannot prepare entity: No model specification with schema provided for ${this.pluralResourceName}`);
+        }
+        return dbUtils.convertStringsToObjectIds(cleanedEntity, this.modelSpec.fullSchema);
+    }
+    prepareQuery(userContext, query) {
+        return query;
+    }
+    prepareQueryOptions(userContext, queryOptions) {
+        return queryOptions;
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,8 @@
+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 './jwt.service.js';
+export * from './multi-tenant-api.service.js';
+export * from './password-reset-token.service.js';
+export * from './tenant-query-decorator.js';

package/dist/services/index.js

@@ -0,0 +1,8 @@
+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 './jwt.service.js';
+export * from './multi-tenant-api.service.js';
+export * from './password-reset-token.service.js';
+export * from './tenant-query-decorator.js';

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

@@ -0,0 +1,4 @@
+export declare class JwtService {
+    static sign(payload: any, secret: string, options: any): string;
+    static verify(token: string, secret: string): any;
+}

package/dist/services/jwt.service.js

@@ -0,0 +1,18 @@
+import jwt from 'jsonwebtoken';
+export class JwtService {
+    static sign(payload, secret, options) {
+        return jwt.sign(payload, secret, options);
+    }
+    static verify(token, secret) {
+        if (!secret) {
+            throw new Error('JWT secret is required for verification');
+        }
+        try {
+            const decoded = jwt.verify(token, secret);
+            return decoded;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Db } from 'mongodb';
+import { IUserContext, IEntity, QueryOptions, IModelSpec } from '@loomcore/common/models';
+import { GenericApiService } from './generic-api.service.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: QueryOptions): QueryOptions;
+    protected prepareEntity(userContext: IUserContext, entity: T, isCreate: boolean): Promise<T | Partial<T>>;
+}

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

@@ -0,0 +1,31 @@
+import { GenericApiService } from './generic-api.service.js';
+import { TenantQueryDecorator } from './tenant-query-decorator.js';
+import { BadRequestError } from '../errors/bad-request.error.js';
+export class MultiTenantApiService extends GenericApiService {
+    tenantDecorator;
+    constructor(db, pluralResourceName, singularResourceName, modelSpec) {
+        super(db, pluralResourceName, singularResourceName, modelSpec);
+        this.tenantDecorator = new TenantQueryDecorator();
+    }
+    prepareQuery(userContext, query) {
+        if (!userContext || !userContext._orgId) {
+            throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQuery');
+        }
+        return this.tenantDecorator.applyTenantToQuery(userContext, query, this.pluralResourceName);
+    }
+    prepareQueryOptions(userContext, queryOptions) {
+        if (!userContext || !userContext._orgId) {
+            throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQueryOptions');
+        }
+        return this.tenantDecorator.applyTenantToQueryOptions(userContext, queryOptions, this.pluralResourceName);
+    }
+    async prepareEntity(userContext, entity, isCreate) {
+        if (!userContext || !userContext._orgId) {
+            throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
+        }
+        const preparedEntity = await super.prepareEntity(userContext, entity, isCreate);
+        const orgIdField = this.tenantDecorator.getOrgIdField();
+        preparedEntity[orgIdField] = userContext._orgId;
+        return preparedEntity;
+    }
+}

package/dist/services/password-reset-token.service.d.ts

@@ -0,0 +1,8 @@
+import { Db } from 'mongodb';
+import { IPasswordResetToken } from '@loomcore/common/models';
+import { GenericApiService } from './generic-api.service.js';
+export declare class PasswordResetTokenService extends GenericApiService<IPasswordResetToken> {
+    constructor(db: Db);
+    createPasswordResetToken(email: string, expiresOn: number): Promise<IPasswordResetToken | null>;
+    getByEmail(email: string): Promise<IPasswordResetToken | null>;
+}

package/dist/services/password-reset-token.service.js

@@ -0,0 +1,20 @@
+import crypto from 'crypto';
+import { EmptyUserContext, PasswordResetTokenSpec } from '@loomcore/common/models';
+import { GenericApiService } from './generic-api.service.js';
+export class PasswordResetTokenService extends GenericApiService {
+    constructor(db) {
+        super(db, 'passwordResetTokens', 'passwordResetToken', PasswordResetTokenSpec);
+    }
+    async createPasswordResetToken(email, expiresOn) {
+        await this.collection.deleteMany({ email });
+        const passwordResetToken = {
+            email,
+            token: crypto.randomBytes(40).toString('hex'),
+            expiresOn: expiresOn,
+        };
+        return super.create(EmptyUserContext, passwordResetToken);
+    }
+    async getByEmail(email) {
+        return await super.findOne(EmptyUserContext, { email });
+    }
+}

package/dist/services/tenant-query-decorator.d.ts

@@ -0,0 +1,14 @@
+import { IUserContext, QueryOptions, IEntity } from '@loomcore/common/models';
+export interface ITenantQueryOptions {
+    orgIdField?: string;
+    excludedCollections?: string[];
+}
+export declare const DEFAULT_TENANT_OPTIONS: ITenantQueryOptions;
+export declare class TenantQueryDecorator {
+    private options;
+    constructor(options?: Partial<ITenantQueryOptions>);
+    applyTenantToQuery(userContext: IUserContext, queryObject: any, collectionName: string): any;
+    applyTenantToQueryOptions(userContext: IUserContext, queryOptions: QueryOptions, collectionName: string): QueryOptions;
+    applyTenantToEntity<T extends IEntity>(userContext: IUserContext, entity: T, collectionName: string): T;
+    getOrgIdField(): string;
+}

package/dist/services/tenant-query-decorator.js

@@ -0,0 +1,66 @@
+import { QueryOptions } from '@loomcore/common/models';
+import { ServerError } from '../errors/index.js';
+export const DEFAULT_TENANT_OPTIONS = {
+    orgIdField: '_orgId',
+    excludedCollections: []
+};
+export class TenantQueryDecorator {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_TENANT_OPTIONS, ...options };
+    }
+    applyTenantToQuery(userContext, queryObject, collectionName) {
+        let result = queryObject;
+        const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
+            userContext?._orgId;
+        if (shouldApplyTenantFilter) {
+            const orgIdField = this.options.orgIdField || '_orgId';
+            result = { ...queryObject, [orgIdField]: userContext._orgId };
+        }
+        else if (!userContext?._orgId) {
+            if (!this.options.excludedCollections?.includes(collectionName)) {
+                throw new ServerError('No _orgId found in userContext');
+            }
+        }
+        return result;
+    }
+    applyTenantToQueryOptions(userContext, queryOptions, collectionName) {
+        let result = queryOptions;
+        const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
+            userContext?._orgId;
+        if (shouldApplyTenantFilter) {
+            const modifiedQueryOptions = new QueryOptions(queryOptions);
+            if (!modifiedQueryOptions.filters) {
+                modifiedQueryOptions.filters = {};
+            }
+            const orgIdField = this.options.orgIdField || '_orgId';
+            modifiedQueryOptions.filters[orgIdField] = { eq: userContext._orgId };
+            result = modifiedQueryOptions;
+        }
+        else if (!userContext?._orgId) {
+            throw new ServerError('No _orgId found in userContext');
+        }
+        return result;
+    }
+    applyTenantToEntity(userContext, entity, collectionName) {
+        let result = entity;
+        const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
+            userContext?._orgId;
+        if (shouldApplyTenantFilter) {
+            const orgIdField = this.options.orgIdField || '_orgId';
+            result = {
+                ...entity,
+                [orgIdField]: userContext._orgId
+            };
+        }
+        else if (!userContext?._orgId) {
+            if (!this.options.excludedCollections?.includes(collectionName)) {
+                throw new ServerError('No _orgId found in userContext');
+            }
+        }
+        return result;
+    }
+    getOrgIdField() {
+        return this.options.orgIdField || '_orgId';
+    }
+}

package/dist/utils/address.utils.d.ts

@@ -0,0 +1,6 @@
+import { IAddress } from '@loomcore/common/models';
+declare function getSingleLineAddress(address: IAddress): string;
+export declare const addressUtils: {
+    getSingleLineAddress: typeof getSingleLineAddress;
+};
+export {};

package/dist/utils/address.utils.js

@@ -0,0 +1,15 @@
+function getSingleLineAddress(address) {
+    const street = address.address1;
+    let singleLineAddress = `${street}`;
+    if (address.address2) {
+        singleLineAddress += ` ${address.address2}`;
+    }
+    if (address.address3) {
+        singleLineAddress += ` ${address.address3}`;
+    }
+    singleLineAddress += `, ${address.city}, ${address.state} ${address.postalCode}`;
+    return singleLineAddress;
+}
+export const addressUtils = {
+    getSingleLineAddress
+};

package/dist/utils/api.utils.d.ts

@@ -0,0 +1,17 @@
+import { Request, Response } from 'express';
+import { TSchema } from '@sinclair/typebox';
+import { IError, QueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+export interface IApiResponseOptions<T> {
+    messages?: string[];
+    errors?: IError[];
+    data?: T;
+}
+declare function apiResponse<T>(response: Response, status: number, options?: IApiResponseOptions<T>, modelSpec?: IModelSpec, publicSchema?: TSchema): Response;
+declare function getQueryOptionsFromRequest(request: Request): QueryOptions;
+declare function getPagedResult<T>(entities: T[], totalRows: number, queryOptions: QueryOptions): IPagedResult<T>;
+export declare const apiUtils: {
+    apiResponse: typeof apiResponse;
+    getQueryOptionsFromRequest: typeof getQueryOptionsFromRequest;
+    getPagedResult: typeof getPagedResult;
+};
+export {};