@loomcore/api 0.0.58 → 0.1.0

package/dist/databases/mongo-db/commands/index.js

@@ -0,0 +1,8 @@
+export * from './mongo-create.command.js';
+export * from './mongo-create-many.command.js';
+export * from './mongo-batch-update.command.js';
+export * from './mongo-full-updateby-id.command.js';
+export * from './mongo-partial-update-by-id.command.js';
+export * from './mongo-update.command.js';
+export * from './mongo-delete-by-id.command.js';
+export * from './mongo-delete-many.command.js';

package/dist/databases/mongo-db/commands/mongo-batch-update.command.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function batchUpdate<T>(db: Db, entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/commands/mongo-batch-update.command.js

@@ -0,0 +1,41 @@
+import { ObjectId } from "mongodb";
+import { BadRequestError } from "../../../errors/index.js";
+import { convertOperationsToPipeline } from "../utils/index.js";
+export async function batchUpdate(db, entities, operations, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    if (!entities || entities.length === 0) {
+        return [];
+    }
+    const bulkOperations = [];
+    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);
+        bulkOperations.push({
+            updateOne: {
+                filter: { _id },
+                update: { $set: updateData },
+            },
+        });
+    }
+    if (bulkOperations.length > 0) {
+        await collection.bulkWrite(bulkOperations);
+    }
+    const baseQuery = { _id: { $in: entityIds } };
+    const operationsDocuments = convertOperationsToPipeline(operations);
+    let updatedEntities;
+    if (operationsDocuments.length > 0) {
+        const pipeline = [
+            { $match: baseQuery },
+            ...operationsDocuments
+        ];
+        updatedEntities = await collection.aggregate(pipeline).toArray();
+    }
+    else {
+        updatedEntities = await collection.find(baseQuery).toArray();
+    }
+    return updatedEntities;
+}

package/dist/databases/mongo-db/commands/mongo-create-many.command.d.ts

@@ -0,0 +1,5 @@
+import { Db } from "mongodb";
+export declare function createMany<T>(db: Db, pluralResourceName: string, entities: Partial<T>[]): Promise<{
+    insertedIds: any;
+    entities: any[];
+}>;

package/dist/databases/mongo-db/commands/mongo-create-many.command.js

@@ -0,0 +1,17 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+export async function createMany(db, pluralResourceName, entities) {
+    try {
+        const collection = db.collection(pluralResourceName);
+        const insertResult = await collection.insertMany(entities);
+        return {
+            insertedIds: insertResult.insertedIds,
+            entities: entities
+        };
+    }
+    catch (err) {
+        if (err.code === 11000) {
+            throw new DuplicateKeyError(`One or more ${pluralResourceName} already exist`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}`);
+    }
+}

package/dist/databases/mongo-db/commands/mongo-create.command.d.ts

@@ -0,0 +1,5 @@
+import { Db } from "mongodb";
+export declare function create<T>(db: Db, pluralResourceName: string, entity: Partial<T>): Promise<{
+    insertedId: any;
+    entity: T;
+}>;

package/dist/databases/mongo-db/commands/mongo-create.command.js

@@ -0,0 +1,17 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+export async function create(db, pluralResourceName, entity) {
+    try {
+        const collection = db.collection(pluralResourceName);
+        const insertResult = await collection.insertOne(entity);
+        return {
+            insertedId: insertResult.insertedId,
+            entity: entity
+        };
+    }
+    catch (err) {
+        if (err.code === 11000) {
+            throw new DuplicateKeyError(`${pluralResourceName} already exists`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}`);
+    }
+}

package/dist/databases/mongo-db/commands/mongo-delete-by-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+export declare function deleteById(db: Db, id: string, pluralResourceName: string): Promise<GenericDeleteResult>;

package/dist/databases/mongo-db/commands/mongo-delete-by-id.command.js

@@ -0,0 +1,14 @@
+import { ObjectId } from "mongodb";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+import { BadRequestError } from "../../../errors/index.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function deleteById(db, id, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    const collection = db.collection(pluralResourceName);
+    const objectId = new ObjectId(id);
+    const baseQuery = { _id: objectId };
+    const deleteResult = await collection.deleteOne(baseQuery);
+    return new GenericDeleteResult(deleteResult.acknowledged, deleteResult.deletedCount);
+}

package/dist/databases/mongo-db/commands/mongo-delete-many.command.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+export declare function deleteMany(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<GenericDeleteResult>;

package/dist/databases/mongo-db/commands/mongo-delete-many.command.js

@@ -0,0 +1,9 @@
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function deleteMany(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const deleteResult = await collection.deleteMany(filter);
+    return new GenericDeleteResult(deleteResult.acknowledged, deleteResult.deletedCount);
+}

package/dist/databases/mongo-db/commands/mongo-full-updateby-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function fullUpdateById<T>(db: Db, operations: Operation[], id: string, entity: any, pluralResourceName: string): Promise<T>;

package/dist/databases/mongo-db/commands/mongo-full-updateby-id.command.js

@@ -0,0 +1,25 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function fullUpdateById(db, operations, id, entity, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch({ filters: { _id: { eq: id } } });
+    const filter = matchDocument.$match;
+    const replaceResult = await collection.replaceOne(filter, entity);
+    if (replaceResult.matchedCount <= 0) {
+        throw new IdNotFoundError();
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch({ filters: { _id: { eq: id } } })
+        .addOperations(operations)
+        .build();
+    const updatedEntity = await collection.aggregate(pipeline).next();
+    if (!updatedEntity) {
+        throw new IdNotFoundError();
+    }
+    return updatedEntity;
+}

package/dist/databases/mongo-db/commands/mongo-partial-update-by-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function partialUpdateById<T>(db: Db, operations: Operation[], id: string, entity: Partial<any>, pluralResourceName: string): Promise<T>;

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

@@ -0,0 +1,25 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function partialUpdateById(db, operations, id, entity, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch({ filters: { _id: { eq: id } } });
+    const filter = matchDocument.$match;
+    const updatedEntity = await collection.findOneAndUpdate(filter, { $set: entity }, { returnDocument: 'after' });
+    if (!updatedEntity) {
+        throw new IdNotFoundError();
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch({ filters: { _id: { eq: id } } })
+        .addOperations(operations)
+        .build();
+    const updatedEntityWithOperations = await collection.aggregate(pipeline).next();
+    if (!updatedEntityWithOperations) {
+        throw new IdNotFoundError();
+    }
+    return updatedEntityWithOperations;
+}

package/dist/databases/mongo-db/commands/mongo-update.command.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export declare function update<T>(db: Db, queryObject: IQueryOptions, entity: Partial<any>, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/commands/mongo-update.command.js

@@ -0,0 +1,19 @@
+import { NotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function update(db, queryObject, entity, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const updateResult = await collection.updateMany(filter, { $set: entity });
+    if (updateResult.matchedCount <= 0) {
+        throw new NotFoundError('No records found matching update query');
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryObject)
+        .addOperations(operations)
+        .addQueryOptions(queryObject, false)
+        .build();
+    const updatedEntities = await collection.aggregate(pipeline).toArray();
+    return updatedEntities;
+}

package/dist/databases/mongo-db/commands/partial-update-by-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function partialUpdateById<T>(db: Db, operations: Operation[], id: string, entity: Partial<any>, pluralResourceName: string): Promise<T>;

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

@@ -0,0 +1,21 @@
+import { IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function partialUpdateById(db, operations, id, entity, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch({ filters: { _id: { eq: id } } });
+    const filter = matchDocument.$match;
+    const updatedEntity = await collection.findOneAndUpdate(filter, { $set: entity }, { returnDocument: 'after' });
+    if (!updatedEntity) {
+        throw new IdNotFoundError();
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch({ filters: { _id: { eq: id } } })
+        .addOperations(operations)
+        .build();
+    const updatedEntityWithOperations = await collection.aggregate(pipeline).next();
+    if (!updatedEntityWithOperations) {
+        throw new IdNotFoundError();
+    }
+    return updatedEntityWithOperations;
+}

package/dist/databases/mongo-db/commands/update.command.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export declare function update<T>(db: Db, queryObject: IQueryOptions, entity: Partial<any>, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/commands/update.command.js

@@ -0,0 +1,19 @@
+import { NotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function update(db, queryObject, entity, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const updateResult = await collection.updateMany(filter, { $set: entity });
+    if (updateResult.matchedCount <= 0) {
+        throw new NotFoundError('No records found matching update query');
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryObject)
+        .addOperations(operations)
+        .addQueryOptions(queryObject, false)
+        .build();
+    const updatedEntities = await collection.aggregate(pipeline).toArray();
+    return updatedEntities;
+}

package/dist/databases/mongo-db/index.d.ts

@@ -0,0 +1,4 @@
+export * from './utils/index.js';
+export * from './mongo-db.database.js';
+export * from './queries/index.js';
+export * from './commands/index.js';

package/dist/databases/mongo-db/index.js

@@ -0,0 +1,4 @@
+export * from './utils/index.js';
+export * from './mongo-db.database.js';
+export * from './queries/index.js';
+export * from './commands/index.js';

package/dist/databases/mongo-db/models/no-sql-pipeline.d.ts

@@ -0,0 +1,15 @@
+import { Document } from "mongodb";
+import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+import { INoSqlPipeline } from "./no-sql-pipeline.interface.js";
+declare class NoSqlPipeline implements INoSqlPipeline {
+    private pipeline;
+    constructor(pipeline?: Document[] | null);
+    addStage(stage: Document): NoSqlPipeline;
+    addStages(stages: Document[]): NoSqlPipeline;
+    addMatch(queryOptions: IQueryOptions, modelSpec?: IModelSpec): NoSqlPipeline;
+    addOperations(operations: Operation[]): NoSqlPipeline;
+    addQueryOptions(queryOptions: IQueryOptions, pagination: boolean): NoSqlPipeline;
+    build(): Document[];
+}
+export default NoSqlPipeline;

package/dist/databases/mongo-db/models/no-sql-pipeline.interface.d.ts

@@ -0,0 +1,11 @@
+import { Document } from "mongodb";
+import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export interface INoSqlPipeline {
+    addStage(stage: Document): INoSqlPipeline;
+    addStages(stages: Document[]): INoSqlPipeline;
+    addMatch(queryOptions: IQueryOptions, modelSpec?: IModelSpec): INoSqlPipeline;
+    addOperations(operations: Operation[]): INoSqlPipeline;
+    addQueryOptions(queryOptions: IQueryOptions, pagination: boolean): INoSqlPipeline;
+    build(): Document[];
+}

package/dist/databases/mongo-db/models/no-sql-pipeline.js

@@ -0,0 +1,43 @@
+import { buildNoSqlMatch, convertOperationsToPipeline, convertQueryOptionsToPipeline } from "../utils/index.js";
+class NoSqlPipeline {
+    pipeline;
+    constructor(pipeline = null) {
+        if (pipeline) {
+            this.pipeline = [...pipeline];
+        }
+        else {
+            this.pipeline = [];
+        }
+    }
+    addStage(stage) {
+        this.pipeline.push(stage);
+        return this;
+    }
+    addStages(stages) {
+        this.pipeline = this.pipeline.concat(stages);
+        return this;
+    }
+    addMatch(queryOptions, modelSpec) {
+        const matchDocument = buildNoSqlMatch(queryOptions, modelSpec);
+        if (matchDocument) {
+            this.pipeline.push(matchDocument);
+        }
+        return this;
+    }
+    addOperations(operations) {
+        const operationsDocuments = convertOperationsToPipeline(operations);
+        if (operationsDocuments.length > 0) {
+            this.pipeline = this.pipeline.concat(operationsDocuments);
+        }
+        return this;
+    }
+    addQueryOptions(queryOptions, pagination) {
+        const queryOptionsDocuments = convertQueryOptionsToPipeline(queryOptions, pagination);
+        this.pipeline = this.pipeline.concat(queryOptionsDocuments);
+        return this;
+    }
+    build() {
+        return this.pipeline;
+    }
+}
+export default NoSqlPipeline;

package/dist/databases/mongo-db/mongo-db.database.d.ts

@@ -0,0 +1,32 @@
+import { Db } from "mongodb";
+import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from "@loomcore/common/models";
+import { Operation } from "../operations/operation.js";
+import { DeleteResult as GenericDeleteResult } from "../models/delete-result.js";
+import { TSchema } from "@sinclair/typebox";
+import { IDatabase } from "../models/database.interface.js";
+export declare class MongoDBDatabase implements IDatabase {
+    private db;
+    constructor(db: Db);
+    preprocessEntity<T extends IEntity>(entity: Partial<T>, schema: TSchema): Partial<T>;
+    postprocessEntity<T extends IEntity>(single: T, schema: TSchema): T;
+    getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getCount(pluralResourceName: string): Promise<number>;
+    create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
+        insertedId: string;
+        entity: T;
+    }>;
+    createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
+        insertedIds: string[];
+        entities: T[];
+    }>;
+    batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    deleteById(id: string, pluralResourceName: string): Promise<GenericDeleteResult>;
+    deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<GenericDeleteResult>;
+    find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
+}

package/dist/databases/mongo-db/mongo-db.database.js

@@ -0,0 +1,65 @@
+import { convertObjectIdsToStrings, convertStringsToObjectIds } from "./utils/index.js";
+import { create, createMany, batchUpdate, fullUpdateById, partialUpdateById, update, deleteById, deleteMany } from "./commands/index.js";
+import { getAll, get, getById, getCount, find, findOne } from "./queries/index.js";
+import { entityUtils } from "@loomcore/common/utils";
+import { BadRequestError } from "../../errors/bad-request.error.js";
+export class MongoDBDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    preprocessEntity(entity, schema) {
+        if (entity._id && !entityUtils.isValidObjectId(entity._id)) {
+            throw new BadRequestError('id is not a valid ObjectId');
+        }
+        return convertStringsToObjectIds(entity, schema);
+    }
+    postprocessEntity(single, schema) {
+        if (!single)
+            return single;
+        return convertObjectIdsToStrings(single);
+    }
+    async getAll(operations, pluralResourceName) {
+        return getAll(this.db, operations, pluralResourceName);
+    }
+    async get(operations, queryOptions, modelSpec, pluralResourceName) {
+        return get(this.db, operations, queryOptions, modelSpec, pluralResourceName);
+    }
+    async getById(operations, queryObject, id, pluralResourceName) {
+        return getById(this.db, operations, queryObject, id, pluralResourceName);
+    }
+    async getCount(pluralResourceName) {
+        return getCount(this.db, pluralResourceName);
+    }
+    async create(entity, pluralResourceName) {
+        return create(this.db, pluralResourceName, entity);
+    }
+    async createMany(entities, pluralResourceName) {
+        return createMany(this.db, pluralResourceName, entities);
+    }
+    async batchUpdate(entities, operations, queryObject, pluralResourceName) {
+        return batchUpdate(this.db, entities, operations, queryObject, pluralResourceName);
+    }
+    async fullUpdateById(operations, id, entity, pluralResourceName) {
+        return fullUpdateById(this.db, operations, id, entity, pluralResourceName);
+    }
+    async partialUpdateById(operations, id, entity, pluralResourceName) {
+        return partialUpdateById(this.db, operations, id, entity, pluralResourceName);
+    }
+    async update(queryObject, entity, operations, pluralResourceName) {
+        return update(this.db, queryObject, entity, operations, pluralResourceName);
+    }
+    async deleteById(id, pluralResourceName) {
+        return deleteById(this.db, id, pluralResourceName);
+    }
+    async deleteMany(queryObject, pluralResourceName) {
+        return deleteMany(this.db, queryObject, pluralResourceName);
+    }
+    async find(queryObject, pluralResourceName) {
+        return find(this.db, queryObject, pluralResourceName);
+    }
+    async findOne(queryObject, pluralResourceName) {
+        return findOne(this.db, queryObject, pluralResourceName);
+    }
+}
+;

package/dist/databases/mongo-db/queries/find-one.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function findOne<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/queries/find-one.query.js

@@ -0,0 +1,9 @@
+import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+export async function findOne(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const options = buildFindOptions(queryObject);
+    const entity = await collection.findOne(filter, options);
+    return entity;
+}

package/dist/databases/mongo-db/queries/find.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function find<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/queries/find.query.js

@@ -0,0 +1,9 @@
+import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+export async function find(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const options = buildFindOptions(queryObject);
+    const entities = await collection.find(filter, options).toArray();
+    return entities;
+}

package/dist/databases/mongo-db/queries/get-all.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function getAll<T>(db: Db, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/queries/get-all.query.js

@@ -0,0 +1,17 @@
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+export async function getAll(db, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const pipeline = new NoSqlPipeline()
+        .addOperations(operations)
+        .build();
+    let aggregateResult;
+    if (pipeline.length === 0) {
+        const cursor = collection.find();
+        aggregateResult = await cursor.toArray();
+    }
+    else {
+        const cursor = collection.aggregate(pipeline);
+        aggregateResult = await cursor.toArray();
+    }
+    return aggregateResult;
+}

package/dist/databases/mongo-db/queries/get-by-id.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function getById<T>(db: Db, operations: Operation[], id: string, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/queries/get-by-id.query.js

@@ -0,0 +1,20 @@
+import { ObjectId } from "mongodb";
+import { convertOperationsToPipeline } from "../utils/index.js";
+export async function getById(db, operations, id, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const objectId = new ObjectId(id);
+    const baseQuery = { _id: objectId };
+    const operationsDocuments = convertOperationsToPipeline(operations);
+    let entity = null;
+    if (operationsDocuments.length > 0) {
+        const pipeline = [
+            { $match: baseQuery },
+            ...operationsDocuments
+        ];
+        entity = await collection.aggregate(pipeline).next();
+    }
+    else {
+        entity = await collection.findOne(baseQuery);
+    }
+    return entity;
+}

package/dist/databases/mongo-db/queries/get-count.query.d.ts

@@ -0,0 +1,2 @@
+import { Db } from "mongodb";
+export declare function getCount(db: Db, pluralResourceName: string): Promise<number>;

package/dist/databases/mongo-db/queries/get-count.query.js

@@ -0,0 +1,5 @@
+export async function getCount(db, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const result = await collection.countDocuments();
+    return result;
+}

package/dist/databases/mongo-db/queries/get.query.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IModelSpec, IQueryOptions, IPagedResult } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export declare function get<T>(db: Db, operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;

package/dist/databases/mongo-db/queries/get.query.js

@@ -0,0 +1,14 @@
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { apiUtils } from "../../../utils/api.utils.js";
+export async function get(db, operations, queryOptions, modelSpec, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryOptions, modelSpec)
+        .addOperations(operations)
+        .addQueryOptions(queryOptions, true)
+        .build();
+    const cursor = collection.aggregate(pipeline);
+    const aggregateResult = await cursor.next();
+    const pagedResult = apiUtils.getPagedResult(aggregateResult?.data || [], aggregateResult?.total || 0, queryOptions);
+    return pagedResult;
+}

package/dist/databases/mongo-db/queries/index.d.ts

@@ -0,0 +1,6 @@
+export * from './mongo-get-all.query.js';
+export * from './mongo-get.query.js';
+export * from './mongo-get-by-id.query.js';
+export * from './mongo-get-count.query.js';
+export * from './mongo-find.query.js';
+export * from './mongo-find-one.query.js';

package/dist/databases/mongo-db/queries/index.js

@@ -0,0 +1,6 @@
+export * from './mongo-get-all.query.js';
+export * from './mongo-get.query.js';
+export * from './mongo-get-by-id.query.js';
+export * from './mongo-get-count.query.js';
+export * from './mongo-find.query.js';
+export * from './mongo-find-one.query.js';

package/dist/databases/mongo-db/queries/mongo-find-one.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function findOne<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/mongo-db/queries/mongo-find-one.query.js

@@ -0,0 +1,9 @@
+import { buildNoSqlMatch, buildFindOptions } from "../utils/index.js";
+export async function findOne(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const options = buildFindOptions(queryObject);
+    const entity = await collection.findOne(filter, options);
+    return entity;
+}

package/dist/databases/mongo-db/queries/mongo-find.query.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+export declare function find<T>(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;