@loomcore/api 0.0.59 → 0.1.0

package/dist/utils/sql.db.utils.js

@@ -0,0 +1,94 @@
+import { stringUtils } from './string.utils.js';
+function buildSQLWhereClauseFromQueryOptions(queryOptions, columnAliasMap) {
+    const filters = queryOptions.filters || {};
+    let whereClause = '';
+    for (const [key, value] of Object.entries(filters)) {
+        if (value) {
+            const tableAlias = (columnAliasMap && columnAliasMap[key]) || '';
+            whereClause = addKeyValueToWhereClause(whereClause, key, value, tableAlias);
+        }
+    }
+    return whereClause;
+}
+function addKeyValueToWhereClause(whereClause, key, value, tableAlias = '') {
+    let column = tableAlias ? `${tableAlias}.${stringUtils.pascalCase(key)}` : stringUtils.pascalCase(key);
+    let formattedValue = '';
+    let operator = '=';
+    if (value) {
+        if (value.eq !== undefined) {
+            formattedValue = formatValue(value.eq);
+            operator = '=';
+        }
+        else if (value.in !== undefined && Array.isArray(value.in)) {
+            const formattedValues = value.in.map(val => formatValue(val)).join(', ');
+            formattedValue = `(${formattedValues})`;
+            operator = 'IN';
+        }
+        else if (value.gte !== undefined) {
+            formattedValue = formatValue(value.gte);
+            operator = '>=';
+        }
+        else if (value.lte !== undefined) {
+            formattedValue = formatValue(value.lte);
+            operator = '<=';
+        }
+        else if (value.gt !== undefined) {
+            formattedValue = formatValue(value.gt);
+            operator = '>';
+        }
+        else if (value.lt !== undefined) {
+            formattedValue = formatValue(value.lt);
+            operator = '<';
+        }
+        else if (value.contains !== undefined) {
+            column = `LOWER(${column})`;
+            formattedValue = formatValue(value.contains, true).toLowerCase();
+            operator = 'LIKE';
+        }
+    }
+    const condition = `${column} ${operator} ${formattedValue}`;
+    return appendToWhereClause(whereClause, condition);
+}
+function appendToWhereClause(whereClause, condition) {
+    let newWhereClause = whereClause.trim();
+    if (newWhereClause.toUpperCase() === 'WHERE' || newWhereClause === '') {
+        newWhereClause = `WHERE ${condition}`;
+    }
+    else {
+        newWhereClause = `${newWhereClause} AND ${condition}`;
+    }
+    return newWhereClause;
+}
+function formatValue(value, isLikeOperator = false) {
+    if (typeof value === 'string') {
+        if (!isNaN(Number(value))) {
+            return value;
+        }
+        if (value.toLowerCase() === 'true') {
+            return 'TRUE';
+        }
+        if (value.toLowerCase() === 'false') {
+            return 'FALSE';
+        }
+        return isLikeOperator ? `'%${value}%'` : `'${value}'`;
+    }
+    else if (typeof value === 'number') {
+        return value.toString();
+    }
+    else if (typeof value === 'boolean') {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    else if (value instanceof Date) {
+        const dateString = value.toISOString().split('T')[0];
+        return `DATETIME('${dateString}')`;
+    }
+    else {
+        throw new Error('Unsupported value type');
+    }
+}
+export const sqlDbUtils = {
+    buildSQLWhereClauseFromQueryOptions,
+    addKeyValueToWhereClause,
+    appendToWhereClause,
+    formatValue,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.59",
+  "version": "0.1.0",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -33,6 +33,7 @@
   "exports": {
     "./config": "./dist/config/index.js",
     "./controllers": "./dist/controllers/index.js",
+    "./database": "./dist/database/index.js",
     "./errors": "./dist/errors/index.js",
     "./middleware": "./dist/middleware/index.js",
     "./models": "./dist/models/index.js",
@@ -42,10 +43,11 @@
   "dependencies": {
     "jsonwebtoken": "^9.0.2",
     "node-mailjet": "^6.0.8",
+    "postgres": "^3.4.7",
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.14",
+    "@loomcore/common": "^0.0.19",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

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

@@ -1,27 +0,0 @@
-import { DeleteResult } from 'mongodb';
-import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
-export interface IGenericApiService<T extends IEntity> {
-    validate(doc: any, isPartial?: boolean): ValueError[] | null;
-    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
-    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
-    prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
-    prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
-    prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
-    prepareDataForBatchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<Partial<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: T | Partial<T>): Promise<T | null>;
-    createMany(userContext: IUserContext, entities: 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>;
-    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?: any): Promise<T[]>;
-    findOne(userContext: IUserContext, mongoQueryObject: any, options?: any): Promise<T>;
-}

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

@@ -1,50 +0,0 @@
-import { Db, Collection, DeleteResult, Document, FindOptions } from 'mongodb';
-import { ValueError } from '@sinclair/typebox/errors';
-import { IUserContext, IEntity, IQueryOptions, 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;
-    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
-    protected getAdditionalPipelineStages(): any[];
-    protected createAggregationPipeline(userContext: IUserContext, query: any, queryOptions?: IQueryOptions): any[];
-    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, preparedEntity: T | Partial<T>): Promise<T | null>;
-    createMany(userContext: IUserContext, preparedEntities: T[]): Promise<T[]>;
-    batchUpdate(userContext: IUserContext, preparedEntities: Partial<T>[]): Promise<T[]>;
-    fullUpdateById(userContext: IUserContext, id: string, preparedEntity: T): Promise<T>;
-    partialUpdateById(userContext: IUserContext, id: string, preparedEntity: Partial<T>): Promise<T>;
-    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, preparedEntity: T): Promise<T>;
-    update(userContext: IUserContext, queryObject: any, preparedEntity: 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, 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;
-    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
-    prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
-    prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
-    prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
-    prepareDataForBatchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<Partial<T>[]>;
-    protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean, allowId?: boolean): Promise<T | Partial<T>>;
-    protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
-    protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
-}

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

@@ -1,424 +0,0 @@
-import { ObjectId } from 'mongodb';
-import moment from 'moment';
-import _ from 'lodash';
-import { DefaultQueryOptions } 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);
-    }
-    validateMany(docs, isPartial = false) {
-        if (!this.modelSpec) {
-            return null;
-        }
-        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;
-    }
-    getAdditionalPipelineStages() {
-        return [];
-    }
-    createAggregationPipeline(userContext, query, queryOptions) {
-        const pipeline = [
-            { $match: query },
-            { $facet: {
-                    data: (() => {
-                        const resultStages = [];
-                        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 resultStages;
-                    })(),
-                    count: [{ $count: 'total' }]
-                } },
-            { $project: {
-                    data: 1,
-                    total: { $arrayElemAt: ['$count.total', 0] }
-                } }
-        ];
-        return pipeline;
-    }
-    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 = { ...DefaultQueryOptions }) {
-        const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
-        const match = dbUtils.buildMongoMatchFromQueryOptions(preparedOptions, this.modelSpec);
-        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 = [
-                { $match: query },
-                ...this.getAdditionalPipelineStages()
-            ];
-            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, preparedEntity) {
-        let createdEntity = null;
-        try {
-            const entity = await this.onBeforeCreate(userContext, preparedEntity);
-            const insertResult = await this.collection.insertOne(entity);
-            if (insertResult.insertedId) {
-                createdEntity = this.transformSingle(entity);
-            }
-            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, preparedEntities) {
-        let createdEntities = [];
-        if (preparedEntities.length) {
-            try {
-                const entities = await this.onBeforeCreate(userContext, preparedEntities);
-                const insertResult = await this.collection.insertMany(entities);
-                if (insertResult.insertedIds) {
-                    createdEntities = this.transformList(entities);
-                }
-                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 batchUpdate(userContext, preparedEntities) {
-        if (!preparedEntities || preparedEntities.length === 0) {
-            return [];
-        }
-        const entities = await this.onBeforeUpdate(userContext, preparedEntities);
-        const operations = [];
-        const entityIds = [];
-        for (const entity of entities) {
-            const { _id, ...updateData } = entity;
-            if (!_id || !(_id instanceof ObjectId)) {
-                throw new BadRequestError('Each entity in a batch update must have a valid _id that has been converted to an ObjectId.');
-            }
-            entityIds.push(_id);
-            operations.push({
-                updateOne: {
-                    filter: { _id },
-                    update: { $set: updateData },
-                },
-            });
-        }
-        if (operations.length > 0) {
-            await this.collection.bulkWrite(operations);
-        }
-        const query = this.prepareQuery(userContext, { _id: { $in: entityIds } });
-        const rawUpdatedEntities = await this.collection.find(query).toArray();
-        const updatedEntities = this.transformList(rawUpdatedEntities);
-        if (updatedEntities.length > 0) {
-            await this.onAfterUpdate(userContext, updatedEntities);
-        }
-        return updatedEntities;
-    }
-    async fullUpdateById(userContext, id, preparedEntity) {
-        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);
-        const existingEntity = await this.collection.findOne(query);
-        if (!existingEntity) {
-            throw new IdNotFoundError();
-        }
-        const auditProperties = {
-            _created: existingEntity._created,
-            _createdBy: existingEntity._createdBy,
-        };
-        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
-        Object.assign(entity, auditProperties);
-        const mongoUpdateResult = await this.collection.replaceOne(query, entity);
-        if (mongoUpdateResult?.matchedCount <= 0) {
-            throw new IdNotFoundError();
-        }
-        await this.onAfterUpdate(userContext, entity);
-        const updatedEntity = await this.collection.findOne(query);
-        return this.transformSingle(updatedEntity);
-    }
-    async partialUpdateById(userContext, id, preparedEntity) {
-        if (!entityUtils.isValidObjectId(id)) {
-            throw new BadRequestError('id is not a valid ObjectId');
-        }
-        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
-        const baseQuery = { _id: new ObjectId(id) };
-        const query = this.prepareQuery(userContext, baseQuery);
-        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: entity }, { returnDocument: 'after' });
-        if (!updatedEntity) {
-            throw new IdNotFoundError();
-        }
-        else {
-            const typedEntity = updatedEntity;
-            await this.onAfterUpdate(userContext, typedEntity);
-        }
-        return this.transformSingle(updatedEntity);
-    }
-    async partialUpdateByIdWithoutBeforeAndAfter(userContext, id, preparedEntity) {
-        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);
-        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, preparedEntity) {
-        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
-        const query = this.prepareQuery(userContext, queryObject);
-        const mongoUpdateResult = await this.collection.updateMany(query, { $set: entity });
-        if (mongoUpdateResult?.matchedCount <= 0) {
-            throw new NotFoundError('No records found matching update query');
-        }
-        await this.onAfterUpdate(userContext, entity);
-        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) {
-        return Promise.resolve(entities);
-    }
-    async onAfterCreate(userContext, entities) {
-        return Promise.resolve(entities);
-    }
-    async onBeforeUpdate(userContext, entities) {
-        return Promise.resolve(entities);
-    }
-    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(userContext, doc, allowId = false) {
-        const isSystemUser = userContext.user?._id === 'system';
-        if (isSystemUser) {
-            return;
-        }
-        const propertiesToIgnore = ['_orgId'];
-        if (allowId) {
-            propertiesToIgnore.push('_id');
-        }
-        for (const key in doc) {
-            if (Object.prototype.hasOwnProperty.call(doc, key) && key.startsWith('_') && !propertiesToIgnore.includes(key)) {
-                delete doc[key];
-            }
-        }
-    }
-    async prepareDataForDb(userContext, entity, isCreate = false) {
-        if (Array.isArray(entity)) {
-            return await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
-        }
-        else {
-            return await this.prepareEntity(userContext, entity, isCreate);
-        }
-    }
-    async prepareDataForBatchUpdate(userContext, entities) {
-        return Promise.all(entities.map(item => this.prepareEntity(userContext, item, false, true)));
-    }
-    async prepareEntity(userContext, entity, isCreate, allowId = false) {
-        const preparedEntity = _.clone(entity);
-        this.stripSenderProvidedSystemProperties(userContext, preparedEntity, allowId);
-        if (this.modelSpec?.isAuditable) {
-            if (isCreate) {
-                this.auditForCreate(userContext, preparedEntity);
-            }
-            else {
-                this.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);
-        }
-        return dbUtils.convertStringsToObjectIds(cleanedEntity, this.modelSpec.fullSchema);
-    }
-    prepareQuery(userContext, query) {
-        return query;
-    }
-    prepareQueryOptions(userContext, queryOptions) {
-        return queryOptions;
-    }
-}

package/dist/utils/db.utils.d.ts

@@ -1,27 +0,0 @@
-import { ObjectId } from 'mongodb';
-import { TSchema } from '@sinclair/typebox';
-import { IQueryOptions, Filter, IModelSpec } from '@loomcore/common/models';
-export declare const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS: string[];
-declare function convertObjectIdsToStrings<T>(entity: T, schema?: TSchema): T;
-declare function convertStringsToObjectIds(entity: any, schema: TSchema): any;
-declare function convertStringToObjectId(value: any): ObjectId | any;
-declare function buildMongoMatchFromQueryOptions(queryOptions: IQueryOptions, modelSpec?: IModelSpec): {
-    $match: any;
-};
-declare function buildSQLWhereClauseFromQueryOptions(queryOptions: IQueryOptions, columnAliasMap: {
-    [key: string]: string;
-}): string;
-declare function addKeyValueToWhereClause(whereClause: string, key: string, value: Filter, tableAlias?: string): string;
-declare function appendToWhereClause(whereClause: string, condition: string): string;
-declare function formatValue(value: string | number | boolean | Date, isLikeOperator?: boolean): string;
-export declare const dbUtils: {
-    buildMongoMatchFromQueryOptions: typeof buildMongoMatchFromQueryOptions;
-    buildSQLWhereClauseFromQueryOptions: typeof buildSQLWhereClauseFromQueryOptions;
-    addKeyValueToWhereClause: typeof addKeyValueToWhereClause;
-    appendToWhereClause: typeof appendToWhereClause;
-    formatValue: typeof formatValue;
-    convertStringToObjectId: typeof convertStringToObjectId;
-    convertStringsToObjectIds: typeof convertStringsToObjectIds;
-    convertObjectIdsToStrings: typeof convertObjectIdsToStrings;
-};
-export {};