flongo 1.2.0 → 1.5.0

package/dist/flongoCollection.d.ts

@@ -130,7 +130,27 @@ export declare class FlongoCollection<T> {
      * @param attributes - Array of document data
      * @param clientId - Optional client ID for audit trail
      */
-    batchCreate(attributes: T[], clientId?: string): Promise<void>;
+    batchCreate(attributes: T[], clientId?: string): Promise<string[]>;
+    /**
+     * Inserts a document if no document with the same _id exists; otherwise does nothing.
+     * Race-safe "first writer wins" semantics — ideal for cache-through writes.
+     * @param attributes - Document data including _id
+     * @param clientId - Optional client ID for audit trail
+     * @returns Promise resolving to the document (newly created or existing)
+     */
+    createIfNotExists(attributes: T & {
+        _id: string;
+    }, clientId?: string): Promise<Entity & T>;
+    /**
+     * Inserts a document if no document with the same _id exists; otherwise overwrites it.
+     * Race-safe "last writer wins" semantics.
+     * @param attributes - Document data including _id
+     * @param clientId - Optional client ID for audit trail
+     * @returns Promise resolving to the document (newly created or updated)
+     */
+    createOrUpdate(attributes: T & {
+        _id: string;
+    }, clientId?: string): Promise<Entity & T>;
     /**
      * Updates multiple documents matching the query
      * @param attributes - Fields to update
@@ -158,29 +178,33 @@ export declare class FlongoCollection<T> {
      * @param id - Document ID
      * @param key - Field name to increment
      * @param amt - Amount to increment by (defaults to 1)
+     * @param clientId - Optional client ID for audit trail
      */
-    increment(id: string, key: string, amt?: number): Promise<void>;
+    increment(id: string, key: string, amt?: number, clientId?: string): Promise<void>;
     /**
      * Atomically decrements a numeric field
      * @param id - Document ID
      * @param key - Field name to decrement
      * @param amt - Amount to decrement by (defaults to 1)
+     * @param clientId - Optional client ID for audit trail
      */
-    decrement(id: string, key: string, amt?: number): Promise<void>;
+    decrement(id: string, key: string, amt?: number, clientId?: string): Promise<void>;
     /**
      * Atomically appends items to an array field
      * @param id - Document ID
      * @param key - Array field name
      * @param items - Items to append to the array
+     * @param clientId - Optional client ID for audit trail
      */
-    append(id: string, key: string, items: any[]): Promise<void>;
+    append(id: string, key: string, items: any[], clientId?: string): Promise<void>;
     /**
      * Atomically removes items from an array field
      * @param id - Document ID
      * @param key - Array field name
      * @param items - Items to remove from the array
+     * @param clientId - Optional client ID for audit trail
      */
-    arrRemove(id: string, key: string, items: any[]): Promise<void>;
+    arrRemove(id: string, key: string, items: any[], clientId?: string): Promise<void>;
     /**
      * Logs an event to the events collection for audit trails
      * Events are only logged if event logging is enabled in options

package/dist/flongoCollection.js

@@ -210,6 +210,7 @@ class FlongoCollection {
             // Insert document with automatic timestamps
             const created = await this.collection.insertOne({
                 ...attributes,
+                createdBy: clientId,
                 createdAt: Date.now(),
                 updatedAt: Date.now()
             });
@@ -236,22 +237,53 @@ class FlongoCollection {
      */
     async batchCreate(attributes, clientId) {
         if (attributes.length === 0)
-            return;
+            return [];
         const now = Date.now();
         // Prepare entities with timestamps
         const entities = attributes.map((attribute) => ({
             ...attribute,
+            createdBy: clientId,
             createdAt: now,
             updatedAt: now
         }));
         // Insert all entities at once
-        await this.collection.insertMany(entities);
+        const result = await this.collection.insertMany(entities);
         // Log batch creation event
         this.logEvent({
             name: types_1.EventName.BatchCreateEntities,
             identity: clientId,
             value: { collectionType: this.name, count: await this.count() }
         });
+        return Object.values(result.insertedIds).map((id) => id.toString());
+    }
+    /**
+     * Inserts a document if no document with the same _id exists; otherwise does nothing.
+     * Race-safe "first writer wins" semantics — ideal for cache-through writes.
+     * @param attributes - Document data including _id
+     * @param clientId - Optional client ID for audit trail
+     * @returns Promise resolving to the document (newly created or existing)
+     */
+    async createIfNotExists(attributes, clientId) {
+        const { _id, ...rest } = attributes;
+        const now = Date.now();
+        const result = await this.collection.findOneAndUpdate({ _id }, { $setOnInsert: { ...rest, createdBy: clientId, createdAt: now, updatedAt: now } }, { upsert: true, returnDocument: 'after' });
+        return this.toEntity(result);
+    }
+    /**
+     * Inserts a document if no document with the same _id exists; otherwise overwrites it.
+     * Race-safe "last writer wins" semantics.
+     * @param attributes - Document data including _id
+     * @param clientId - Optional client ID for audit trail
+     * @returns Promise resolving to the document (newly created or updated)
+     */
+    async createOrUpdate(attributes, clientId) {
+        const { _id, createdAt, createdBy, updatedAt, updatedBy, ...rest } = attributes;
+        const now = Date.now();
+        const result = await this.collection.findOneAndUpdate({ _id }, {
+            $set: { ...rest, updatedAt: now, updatedBy: clientId },
+            $setOnInsert: { createdAt: now, createdBy: clientId }
+        }, { upsert: true, returnDocument: 'after' });
+        return this.toEntity(result);
     }
     // ===========================================
     // UPDATE OPERATIONS
@@ -268,6 +300,7 @@ class FlongoCollection {
         await this.collection.updateMany(mongodbQuery, {
             $set: {
                 updatedAt: Date.now(),
+                updatedBy: clientId,
                 ...attributes
             }
         });
@@ -294,6 +327,7 @@ class FlongoCollection {
             await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
                 $set: {
                     updatedAt: Date.now(),
+                    updatedBy: clientId,
                     ...attributes
                 }
             });
@@ -321,6 +355,7 @@ class FlongoCollection {
         const update = {
             $set: {
                 updatedAt: Date.now(),
+                updatedBy: clientId,
                 ...attributes
             }
         };
@@ -340,29 +375,38 @@ class FlongoCollection {
      * @param id - Document ID
      * @param key - Field name to increment
      * @param amt - Amount to increment by (defaults to 1)
+     * @param clientId - Optional client ID for audit trail
      */
-    async increment(id, key, amt) {
-        const inc = { $inc: { [key]: amt || 1 } };
-        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, inc);
+    async increment(id, key, amt, clientId) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
+            $inc: { [key]: amt || 1 },
+            $set: { updatedAt: Date.now(), updatedBy: clientId }
+        });
     }
     /**
      * Atomically decrements a numeric field
      * @param id - Document ID
      * @param key - Field name to decrement
      * @param amt - Amount to decrement by (defaults to 1)
+     * @param clientId - Optional client ID for audit trail
      */
-    async decrement(id, key, amt) {
-        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $inc: { [key]: -(amt ?? 1) } });
+    async decrement(id, key, amt, clientId) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
+            $inc: { [key]: -(amt ?? 1) },
+            $set: { updatedAt: Date.now(), updatedBy: clientId }
+        });
     }
     /**
      * Atomically appends items to an array field
      * @param id - Document ID
      * @param key - Array field name
      * @param items - Items to append to the array
+     * @param clientId - Optional client ID for audit trail
      */
-    async append(id, key, items) {
+    async append(id, key, items, clientId) {
         await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
-            $push: { [key]: { $each: items } }
+            $push: { [key]: { $each: items } },
+            $set: { updatedAt: Date.now(), updatedBy: clientId }
         });
     }
     /**
@@ -370,9 +414,13 @@ class FlongoCollection {
      * @param id - Document ID
      * @param key - Array field name
      * @param items - Items to remove from the array
+     * @param clientId - Optional client ID for audit trail
      */
-    async arrRemove(id, key, items) {
-        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $pull: { [key]: { $in: items } } });
+    async arrRemove(id, key, items, clientId) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
+            $pull: { [key]: { $in: items } },
+            $set: { updatedAt: Date.now(), updatedBy: clientId }
+        });
     }
     // ===========================================
     // EVENT LOGGING

package/dist/mongo.d.ts

@@ -0,0 +1,9 @@
+import { Db, MongoClient } from "mongodb";
+export declare let mongoClient: MongoClient;
+export declare let mongoDb: Db;
+export interface MongoConfig {
+    connectionString: string;
+    dbName: string;
+}
+export declare function initializeMongo(config: MongoConfig): void;
+//# sourceMappingURL=mongo.d.ts.map

package/dist/mongo.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoDb = exports.mongoClient = void 0;
+exports.initializeMongo = initializeMongo;
+const mongodb_1 = require("mongodb");
+function initializeMongo(config) {
+    exports.mongoClient = new mongodb_1.MongoClient(config.connectionString);
+    exports.mongoDb = exports.mongoClient.db(config.dbName);
+}
+//# sourceMappingURL=mongo.js.map

package/dist/mongoCollection.d.ts

@@ -0,0 +1,33 @@
+import { MongoCollectionQuery } from "./mongoCollectionQuery";
+import { Entity, Event, EventName, Pagination, Repository } from "./types";
+export interface MongoCollectionOptions {
+    enableEventLogging?: boolean;
+    eventsCollectionName?: string;
+}
+export declare class MongoCollection<T> {
+    private collection;
+    private events;
+    private name;
+    private options;
+    constructor(collectionName: Repository, options?: MongoCollectionOptions);
+    get(id: string): Promise<Entity & T>;
+    private toEntity;
+    getAll(query?: MongoCollectionQuery, pagination?: Pagination): Promise<(Entity & T)[]>;
+    getSome(query: MongoCollectionQuery, pagination: Pagination): Promise<(Entity & T)[]>;
+    getFirst(query: MongoCollectionQuery): Promise<Entity & T>;
+    count(query?: MongoCollectionQuery): Promise<number>;
+    delete(id: string, clientId: string): Promise<void>;
+    batchDelete(ids: string[], clientId: string): Promise<void>;
+    exists(query: MongoCollectionQuery): Promise<boolean>;
+    logEvent<T extends EventName>(event: Event<T>): Promise<string | null>;
+    create(attributes: T, clientId?: string): Promise<Entity & T>;
+    batchCreate(attributes: T[], clientId?: string): Promise<void>;
+    updateAll(attributes: any, query?: MongoCollectionQuery, clientId?: string): Promise<void>;
+    update(id: string, attributes: any, clientId?: string): Promise<void>;
+    increment(id: string, key: string, amt?: number): Promise<void>;
+    decrement(id: string, key: string, amt?: number): Promise<void>;
+    append(id: string, key: string, items: any[]): Promise<void>;
+    arrRemove(id: string, key: string, items: any[]): Promise<void>;
+    updateFirst(attributes: any, query?: MongoCollectionQuery, clientId?: string): Promise<Entity & T>;
+}
+//# sourceMappingURL=mongoCollection.d.ts.map

package/dist/mongoCollection.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCollection = void 0;
+const mongo_1 = require("./mongo");
+const mongoCollectionQuery_1 = require("./mongoCollectionQuery");
+const types_1 = require("./types");
+const mongodb_1 = require("mongodb");
+const errors_1 = require("./errors");
+class MongoCollection {
+    constructor(collectionName, options = {}) {
+        this.collection = mongo_1.mongoDb.collection(collectionName);
+        this.options = { enableEventLogging: true, eventsCollectionName: "events", ...options };
+        this.events = this.options.enableEventLogging
+            ? mongo_1.mongoDb.collection(this.options.eventsCollectionName)
+            : null;
+        this.name = collectionName;
+    }
+    async get(id) {
+        const objId = new mongodb_1.ObjectId(id);
+        const docWithId = await this.collection.findOne({ _id: objId });
+        if (docWithId) {
+            return this.toEntity(docWithId);
+        }
+        else {
+            console.error("Could not find id: " + id);
+            throw new errors_1.Error404();
+        }
+    }
+    toEntity(obj) {
+        return { ...obj, _id: String(obj._id) };
+    }
+    async getAll(query, pagination) {
+        const mongodbQuery = query?.build() ?? {};
+        const mongodbOptions = query?.buildOptions(pagination) ?? {};
+        try {
+            const res = await this.collection.find(mongodbQuery, mongodbOptions).toArray();
+            return res.map((d) => this.toEntity(d));
+        }
+        catch (err) {
+            console.log("getAll() Failed: Query: " +
+                JSON.stringify(mongodbQuery, null, 2) +
+                " err: " +
+                JSON.stringify(err, null, 2));
+            throw err;
+        }
+    }
+    async getSome(query, pagination) {
+        const mongodbQuery = query?.build();
+        const mongodbOptions = query?.buildOptions(pagination);
+        return (await this.collection.find(mongodbQuery, mongodbOptions).toArray()).map((d) => this.toEntity(d));
+    }
+    async getFirst(query) {
+        const mongodbQuery = query?.build();
+        const mongodbOptions = query?.buildOptions();
+        return this.toEntity(await this.collection.findOne(mongodbQuery, mongodbOptions));
+    }
+    async count(query) {
+        const mongodbQuery = query?.build() ?? {};
+        return this.collection.countDocuments(mongodbQuery);
+    }
+    async delete(id, clientId) {
+        const entity = await this.get(id);
+        this.logEvent({
+            name: types_1.EventName.DeleteEntity,
+            value: {
+                id,
+                collectionType: this.name,
+                count: await this.count(),
+                backup: entity,
+                deletedBy: clientId
+            }
+        });
+        await this.collection.deleteOne({ _id: new mongodb_1.ObjectId(id) });
+    }
+    async batchDelete(ids, clientId) {
+        const mongodbQuery = { _id: { $in: ids } };
+        const entities = await this.getAll(new mongoCollectionQuery_1.MongoCollectionQuery().where("_id").in(ids));
+        this.logEvent({
+            name: types_1.EventName.BatchDeleteEntities,
+            value: {
+                collectionType: this.name,
+                count: await this.count(),
+                backup: entities,
+                deletedBy: clientId
+            }
+        });
+        await this.collection.deleteMany({ mongodbQuery });
+    }
+    async exists(query) {
+        try {
+            const count = await this.collection.countDocuments(query.build());
+            return count > 0;
+        }
+        catch (err) {
+            console.log("Error getting count... " + JSON.stringify(err, null, 2));
+            return false;
+        }
+    }
+    async logEvent(event) {
+        if (!this.events) {
+            return null; // Event logging is disabled
+        }
+        const created = await this.events.insertOne({
+            ...event,
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+        });
+        return String(created.insertedId);
+    }
+    async create(attributes, clientId) {
+        // implement clientId
+        try {
+            const created = await this.collection.insertOne({
+                ...attributes,
+                // _id: id,
+                createdAt: Date.now(),
+                updatedAt: Date.now()
+            });
+            const entity = this.toEntity(await this.get(created.insertedId));
+            this.logEvent({
+                name: types_1.EventName.CreateEntity,
+                identity: clientId,
+                value: { id: entity._id, collectionType: this.name, count: await this.count() }
+            });
+            return entity;
+        }
+        catch (err) {
+            console.error("Failed create: " + JSON.stringify(err, null, 2));
+            throw err;
+        }
+    }
+    async batchCreate(attributes, clientId) {
+        // implement clientId
+        const now = Date.now();
+        const entities = attributes.map((attribute) => ({
+            ...attribute,
+            //_id: uuidv4(),
+            createdAt: now,
+            updatedAt: now
+        }));
+        if (entities.length > 0) {
+            await this.collection.insertMany(entities);
+            this.logEvent({
+                name: types_1.EventName.BatchCreateEntities,
+                identity: clientId,
+                value: { collectionType: this.name, count: await this.count() }
+            });
+        }
+    }
+    async updateAll(attributes, query, clientId) {
+        // implement attributes, filters and clientId
+        const mongodbQuery = query?.build() ?? {};
+        await this.collection.updateMany(mongodbQuery, {
+            $set: {
+                updatedAt: Date.now(),
+                ...attributes
+            }
+        });
+        this.logEvent({
+            name: types_1.EventName.BatchUpdateEntities,
+            identity: clientId,
+            value: { collectionType: this.name }
+        });
+    }
+    async update(id, attributes, clientId) {
+        // implement attributes and clientId
+        if ("_id" in attributes) {
+            delete attributes._id;
+        }
+        try {
+            await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
+                $set: {
+                    updatedAt: Date.now(),
+                    ...attributes
+                }
+            });
+            this.logEvent({
+                name: types_1.EventName.UpdateEntity,
+                identity: clientId,
+                value: { collectionType: this.name, id }
+            });
+        }
+        catch (err) {
+            console.error("Failed updating: " + JSON.stringify(err, null, 2));
+            throw err;
+        }
+    }
+    async increment(id, key, amt) {
+        const inc = { $inc: { [key]: amt || 1 } };
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, inc);
+    }
+    async decrement(id, key, amt) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $inc: { [key]: amt ?? -1 } });
+    }
+    async append(id, key, items) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
+            $push: { [key]: { $each: items } }
+        });
+    }
+    async arrRemove(id, key, items) {
+        await this.collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $pull: { [key]: { $in: items } } });
+    }
+    async updateFirst(attributes, query, clientId) {
+        const mongodbQuery = query?.build() ?? {};
+        const update = {
+            $set: {
+                updatedAt: Date.now(),
+                ...attributes
+            }
+        };
+        const updated = await this.collection.findOneAndUpdate(mongodbQuery, update);
+        if (updated) {
+            return this.toEntity(updated);
+        }
+        else {
+            throw new Error("Failed to update entity");
+        }
+    }
+}
+exports.MongoCollection = MongoCollection;
+//# sourceMappingURL=mongoCollection.js.map

package/dist/mongoCollectionQuery.d.ts

@@ -0,0 +1,43 @@
+import { Bounds, Coordinates, Pagination, ColExpression, ColRange, ICollectionQuery, Logic, SortDirection } from "./types";
+import { Document, Filter, FindOptions } from "mongodb";
+export declare class MongoCollectionQuery implements ICollectionQuery {
+    expressions: ColExpression[];
+    ranges: ColRange[];
+    orderField?: string;
+    orderDirection?: SortDirection;
+    orQueries: MongoCollectionQuery[];
+    andQueries: MongoCollectionQuery[];
+    private exp;
+    set(op?: string, val?: any): MongoCollectionQuery;
+    setRange(key: string, start: any, end: any, orderField: string): void;
+    where(key: string): MongoCollectionQuery;
+    and(key: string): MongoCollectionQuery;
+    eq(val?: any): MongoCollectionQuery;
+    neq(val?: any): MongoCollectionQuery;
+    lt(val?: any): MongoCollectionQuery;
+    ltEq(val?: any): MongoCollectionQuery;
+    gt(val?: any): MongoCollectionQuery;
+    gtEq(val?: any): MongoCollectionQuery;
+    arrContains(val?: any): MongoCollectionQuery;
+    arrContainsAll(val?: any): MongoCollectionQuery;
+    arrContainsAny(val?: any[]): MongoCollectionQuery;
+    startsWith(val: string): MongoCollectionQuery;
+    endsWith(val: string): MongoCollectionQuery;
+    strContains(val: string): MongoCollectionQuery;
+    private applyComparisonOperator;
+    in(val?: any[]): MongoCollectionQuery;
+    notIn(val?: any[]): MongoCollectionQuery;
+    inRange(key: string, min: any, max: any): MongoCollectionQuery;
+    inRadius(key: string, center: Coordinates, radius: number): MongoCollectionQuery;
+    geoWithin(bounds?: Bounds): MongoCollectionQuery;
+    orderBy(field?: string, direction?: SortDirection): MongoCollectionQuery;
+    andQuery(query: MongoCollectionQuery): MongoCollectionQuery;
+    or(query: MongoCollectionQuery): MongoCollectionQuery;
+    build<T>(): Filter<T>;
+    buildOptions<T extends Document>(pagination?: Pagination): FindOptions<T>;
+}
+export declare class CollectionQueryBuilder {
+    q: MongoCollectionQuery;
+}
+export { Logic };
+//# sourceMappingURL=mongoCollectionQuery.d.ts.map

package/dist/mongoCollectionQuery.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logic = exports.CollectionQueryBuilder = exports.MongoCollectionQuery = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const types_1 = require("./types");
+Object.defineProperty(exports, "Logic", { enumerable: true, get: function () { return types_1.Logic; } });
+const geofire_common_1 = require("geofire-common");
+const mongodb_1 = require("mongodb");
+class MongoCollectionQuery {
+    constructor() {
+        this.expressions = [];
+        this.ranges = [];
+        this.orQueries = [];
+        this.andQueries = [];
+    }
+    exp() {
+        return this.expressions[this.expressions.length - 1];
+    }
+    set(op, val) {
+        if (!val) {
+            this.expressions.pop();
+            return this;
+        }
+        this.exp().op = op;
+        this.exp().val = val;
+        return this;
+    }
+    setRange(key, start, end, orderField) {
+        this.orderBy(orderField);
+        this.ranges.push({ key: key, start: start, end: end });
+    }
+    where(key) {
+        this.expressions.push(new types_1.ColExpression(key));
+        return this;
+    }
+    and(key) {
+        this.where(key);
+        return this;
+    }
+    eq(val) {
+        return this.set("$eq", val);
+    }
+    neq(val) {
+        return this.set("$ne", val);
+    }
+    lt(val) {
+        return this.set("$lt", val);
+    }
+    ltEq(val) {
+        return this.set("$lte", val);
+    }
+    gt(val) {
+        return this.set("$gt", val);
+    }
+    gtEq(val) {
+        return this.set("$gte", val);
+    }
+    arrContains(val) {
+        return this.set(undefined, val);
+    }
+    arrContainsAll(val) {
+        return this.set("$all", val);
+    }
+    arrContainsAny(val) {
+        if (val && val.length > 0) {
+            this.set("$in", val);
+        }
+        else {
+            this.expressions.pop();
+        }
+        return this;
+    }
+    startsWith(val) {
+        return this.set("$regex", "^" + val);
+    }
+    endsWith(val) {
+        return this.set("$regex", val + "$");
+    }
+    strContains(val) {
+        return this.set("$regex", val);
+    }
+    applyComparisonOperator(op, val) {
+        if (val) {
+            this.set(op, val);
+        }
+        else {
+            this.expressions.pop();
+        }
+        return this;
+    }
+    in(val) {
+        return this.applyComparisonOperator("$in", val);
+    }
+    notIn(val) {
+        return val?.length ?? 0 > 0 ? this.applyComparisonOperator("$nin", val) : this;
+    }
+    inRange(key, min, max) {
+        return this.where(key).gtEq(min).and(key).ltEq(max);
+    }
+    inRadius(key, center, radius) {
+        const geoBounds = (0, geofire_common_1.geohashQueryBounds)([center.latitude, center.longitude], radius);
+        this.orderBy(key, types_1.SortDirection.Ascending);
+        for (const b of geoBounds) {
+            this.or(new MongoCollectionQuery().inRange(key, b[0], b[1]));
+        }
+        return this;
+    }
+    geoWithin(bounds) {
+        if (bounds) {
+            this.set("$geoWithin", {
+                $geometry: {
+                    type: "Polygon",
+                    coordinates: [
+                        [
+                            [bounds.ne.longitude, bounds.ne.latitude],
+                            [bounds.ne.longitude, bounds.sw.latitude],
+                            [bounds.sw.longitude, bounds.sw.latitude],
+                            [bounds.sw.longitude, bounds.ne.latitude],
+                            [bounds.ne.longitude, bounds.ne.latitude]
+                        ]
+                    ]
+                }
+            });
+        }
+        else {
+            this.expressions.pop();
+        }
+        return this;
+    }
+    orderBy(field, direction) {
+        this.orderField = field;
+        this.orderDirection = direction;
+        return this;
+    }
+    andQuery(query) {
+        if (this.expressions.length > 0) {
+            this.andQueries.push(query);
+        }
+        return query;
+    }
+    or(query) {
+        this.orQueries.push(query);
+        return this;
+    }
+    build() {
+        let mongodbQuery = {};
+        //console.log("Building query: " + JSON.stringify(this, null, 2));
+        try {
+            if (this.expressions) {
+                for (const expression of this.expressions) {
+                    //console.log("EXPRESSION: " + JSON.stringify(expression, null, 2));
+                    if (expression.key === "_id") {
+                        if (Array.isArray(expression.val)) {
+                            mongodbQuery = {
+                                _id: {
+                                    [expression.op ?? "$in"]: expression.val.map((element) => new mongodb_1.ObjectId(element))
+                                }
+                            };
+                        }
+                        else {
+                            mongodbQuery = { _id: new mongodb_1.ObjectId(expression.val) };
+                        }
+                        break;
+                    }
+                    mongodbQuery[expression.key] = expression.op
+                        ? expression.op === "$regex"
+                            ? { [expression.op]: expression.val, ["$options"]: "i" }
+                            : { [expression.op]: expression.val }
+                        : expression.val;
+                }
+            }
+            if (this.orQueries.length > 0) {
+                //console.log("Found OR queries");
+                mongodbQuery["$or"] = [];
+                for (const query of this.orQueries) {
+                    //console.log("OR QUERY: " + JSON.stringify(query, null, 2));
+                    mongodbQuery["$or"].push(query.build());
+                }
+            }
+            if (this.andQueries.length > 0) {
+                mongodbQuery["$and"] = [];
+                for (const query of this.andQueries) {
+                    mongodbQuery["$and"].push(query.build());
+                }
+            }
+        }
+        catch (err) {
+            console.log("Failed building query: " + JSON.stringify(err.message, null, 2));
+            throw err;
+        }
+        // if (query.ranges) {
+        //   query.ranges.forEach((range) => {
+        //     mongodbQuery[range.key as keyof Filter<T>] = {
+        //       $gte: range.start,
+        //       $lt: range.end
+        //     };
+        //   });
+        // }
+        //console.log("query: " + JSON.stringify(mongodbQuery, null, 2));
+        return mongodbQuery;
+    }
+    buildOptions(pagination) {
+        const mongodbOptions = {};
+        if (pagination) {
+            mongodbOptions.skip = pagination.offset;
+            mongodbOptions.limit = pagination.count;
+        }
+        if (this.orderField && this.orderDirection) {
+            mongodbOptions.sort = {
+                [this.orderField]: this.orderDirection === types_1.SortDirection.Ascending ? 1 : -1
+            };
+        }
+        //console.log(this.name + " mongo options: " + JSON.stringify(mongodbOptions, null, 2));
+        return mongodbOptions;
+    }
+}
+exports.MongoCollectionQuery = MongoCollectionQuery;
+class CollectionQueryBuilder {
+    constructor() {
+        this.q = new MongoCollectionQuery();
+    }
+}
+exports.CollectionQueryBuilder = CollectionQueryBuilder;
+//# sourceMappingURL=mongoCollectionQuery.js.map

package/dist/types.d.ts

@@ -76,7 +76,7 @@ export type ICollection<T> = {
     batchDelete: (ids: string[], clientId?: string) => Promise<void>;
     exists: (query: ICollectionQuery) => Promise<boolean>;
     create: (attributes: T, clientId?: string) => Promise<Entity & T>;
-    batchCreate: (attributes: T[], clientId?: string) => Promise<void>;
+    batchCreate: (attributes: T[], clientId?: string) => Promise<string[]>;
     updateAll: (attributes: any, filters?: any, clientId?: string) => Promise<void>;
     update: (id: string, attributes: any, clientId?: string) => Promise<void>;
     increment: (id: string, key: string, amt?: number) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flongo",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "description": "Firestore-like fluent query API for MongoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "test:coverage": "vitest --coverage",
     "lint": "echo 'Linting not configured yet'",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build && npm test",
+    "prepublishOnly": "npm run build && vitest --run",
     "semantic-release": "semantic-release"
   },
   "keywords": [