@opra/mongodb 0.17.1 → 0.17.2

package/cjs/mongo-collection-resource.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoCollectionResource = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@opra/common");
+const core_1 = require("@opra/core");
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
-class MongoCollectionResource {
-    constructor() {
-        this.defaultLimit = 100;
+// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+class MongoCollectionResource extends core_1.CollectionResourceBase {
+    constructor(options) {
+        super(options);
     }
     async create(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
@@ -26,18 +28,12 @@ class MongoCollectionResource {
     async get(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.findOne(prepared.filter, prepared.options);
-        if (!out)
-            throw new common_1.ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.findOne(prepared.filter, prepared.options);
     }
     async update(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.updateOne(prepared.filter, prepared.update, prepared.options);
-        if (!out)
-            throw new common_1.ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.updateOne(prepared.filter, prepared.update, prepared.options);
     }
     async updateMany(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);

package/cjs/mongo-entity-service.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoEntityService = void 0;
 class MongoEntityService {
-    constructor(collectionName, options) {
-        this.collectionName = collectionName;
+    constructor(arg0, arg1) {
+        const options = typeof arg0 === 'object' ? arg0 : arg1;
+        if (typeof arg0 === 'string')
+            this._collectionName = arg0;
         this.db = options?.db;
         this.defaultLimit = options?.defaultLimit || 10;
     }
     async count(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -22,7 +25,8 @@ class MongoEntityService {
         }
     }
     async deleteOne(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -37,7 +41,8 @@ class MongoEntityService {
         }
     }
     async deleteMany(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -52,7 +57,8 @@ class MongoEntityService {
         }
     }
     async findOne(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -65,35 +71,40 @@ class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
         return out;
     }
     async find(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             limit: options?.limit || this.defaultLimit,
             session: options?.session || this.session
         };
         const out = [];
+        let cursor;
         try {
-            const cursor = collection.find(filter, options);
-            let row;
-            while (row = await cursor.next()) {
-                if (this.onTransformRow)
-                    row = this.onTransformRow(row);
-                out.push(row);
+            cursor = collection.find(filter, options);
+            let obj;
+            while (out.length < this.defaultLimit && (obj = await cursor.next())) {
+                const v = this.transformData ? this.transformData(obj) : obj;
+                if (v)
+                    out.push(obj);
             }
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
+        finally {
+            if (cursor)
+                await cursor.close();
+        }
         return out;
     }
     async insertOne(doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         let out;
         options = {
             ...options,
@@ -108,14 +119,15 @@ class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
+        if (this.transformData)
+            out = this.transformData(out);
         if (!out)
             throw new Error('"insertOne" operation returned no result!');
         return out;
     }
     async updateOne(filter, doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         let out;
         options = {
             ...options,
@@ -130,12 +142,13 @@ class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
+        if (this.transformData)
+            out = this.transformData(out);
         return out;
     }
     async updateMany(filter, doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session,
@@ -175,5 +188,15 @@ class MongoEntityService {
             throw new Error(`Database not set!`);
         return this.db;
     }
+    async getCollection(db) {
+        if (!this._collectionName)
+            throw new Error('collectionName is not assigned');
+        return db.collection(this.getCollectionName());
+    }
+    getCollectionName() {
+        if (!this._collectionName)
+            throw new Error('collectionName is not defined');
+        return this._collectionName;
+    }
 }
 exports.MongoEntityService = MongoEntityService;

package/cjs/mongo-singleton-resource.js

@@ -22,18 +22,12 @@ class MongoSingletonResource {
     async get(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.findOne(prepared.filter, prepared.options);
-        if (!out)
-            throw new common_1.ResourceNotFoundError(service.collectionName);
-        return out;
+        return service.findOne(prepared.filter, prepared.options);
     }
     async update(ctx) {
         const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.updateOne(prepared.filter, prepared.update, prepared.options);
-        if (!out)
-            throw new common_1.ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.updateOne(prepared.filter, prepared.update, prepared.options);
     }
 }
 tslib_1.__decorate([

package/cjs/transform-filter.js

@@ -1,96 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("@opra/core");
 const common_1 = require("@opra/common");
-function transformFilter(str) {
-    const ast = typeof str === 'string' ? (0, common_1.parseFilter)(str) : str;
+const opMap = {
+    '=': '$eq',
+    '!=': '$ne',
+    '>': '$gt',
+    '>=': '$gte',
+    '<': '$lt',
+    '<=': '$lte',
+    'in': '$in',
+    '!in': '$nin',
+};
+function transformFilter(ast, negative) {
     if (!ast)
         return;
-    if (ast instanceof common_1.ComparisonExpression) {
-        const left = ast.left instanceof common_1.QualifiedIdentifier
-            ? ast.left.value
-            : transformFilter(ast.left);
-        const right = transformFilter(ast.right);
-        switch (ast.op) {
-            case '=':
+    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof common_1.OpraFilter.NumberLiteral ||
+        ast instanceof common_1.OpraFilter.StringLiteral ||
+        ast instanceof common_1.OpraFilter.BooleanLiteral ||
+        ast instanceof common_1.OpraFilter.NullLiteral ||
+        ast instanceof common_1.OpraFilter.DateLiteral ||
+        ast instanceof common_1.OpraFilter.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof common_1.OpraFilter.ArrayExpression) {
+        return ast.items.map(x => transformFilter(x, negative));
+    }
+    if (ast instanceof common_1.OpraFilter.NegativeExpression) {
+        return transformFilter(ast.expression, !negative);
+    }
+    if (ast instanceof common_1.OpraFilter.LogicalExpression) {
+        if (ast.op === 'or')
+            return { $or: ast.items.map(x => transformFilter(x, negative)) };
+        return { $and: ast.items.map(x => transformFilter(x, negative)) };
+    }
+    if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
+        return transformFilter(ast.expression, negative);
+    }
+    if (ast instanceof common_1.OpraFilter.ComparisonExpression) {
+        const left = transformFilter(ast.left, negative);
+        if (ast.right instanceof common_1.OpraFilter.QualifiedIdentifier) {
+            const op = opMap[ast.op];
+            if (op)
+                return { $expr: { [op]: ["$" + left, "$" + ast.right.value] } };
+            /* istanbul ignore next */
+            throw new Error(`Invalid filter query.`);
+        }
+        let right = transformFilter(ast.right);
+        if (right == null) {
+            const op = ast.op === '='
+                ? (negative ? '!=' : '=')
+                : (negative ? '=' : '!=');
+            if (op === '=')
+                return { $or: [{ [left]: null }, { [left]: { $exists: false } }] };
+            if (op === '!=')
+                return { $and: [{ $ne: { [left]: null } }, { [left]: { $exists: true } }] };
+        }
+        const mngOp = opMap[ast.op];
+        if (mngOp) {
+            if (ast.op === 'in' || ast.op === '!in')
+                right = Array.isArray(right) ? right : [right];
+            if (ast.op === '=' && !negative)
                 return { [left]: right };
-            case '!=':
-                return { [left]: { $ne: right } };
-            case '>':
-                return { [left]: { $gt: right } };
-            case '>=':
-                return { [left]: { $gte: right } };
-            case '<':
-                return { [left]: { $lt: right } };
-            case '<=':
-                return { [left]: { $lte: right } };
-            case 'in':
-                return { [left]: { $in: Array.isArray(right) ? right : [right] } };
-            case '!in':
-                return { [left]: { $nin: Array.isArray(right) ? right : [right] } };
+            return { [left]: wrapNot({ [mngOp]: right }, negative) };
+        }
+        switch (ast.op) {
             case 'like':
                 return {
-                    [left]: {
+                    [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
                             $caseSensitive: true
                         }
-                    }
+                    }, negative)
                 };
             case 'ilike':
                 return {
-                    [left]: {
+                    [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
                         }
-                    }
+                    }, negative)
                 };
             case '!like':
                 return {
-                    [left]: {
-                        $not: {
-                            $text: {
-                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
-                                $caseSensitive: true
-                            }
+                    [left]: wrapNot({
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                            $caseSensitive: true
                         }
-                    }
+                    }, !negative)
                 };
             case '!ilike':
                 return {
-                    [left]: {
-                        $not: {
-                            $text: {
-                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
-                            }
+                    [left]: wrapNot({
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
                         }
-                    }
+                    }, !negative)
                 };
-            default:
-                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
         }
+        throw new Error(`Unimplemented ComparisonExpression operation (right side is ${ast.right.kind})`);
     }
-    if (ast instanceof common_1.QualifiedIdentifier) {
-        return ast.value;
-    }
-    if (ast instanceof common_1.NumberLiteral ||
-        ast instanceof common_1.StringLiteral ||
-        ast instanceof common_1.BooleanLiteral ||
-        ast instanceof common_1.NullLiteral ||
-        ast instanceof common_1.DateLiteral ||
-        ast instanceof common_1.TimeLiteral) {
-        return ast.value;
-    }
-    if (ast instanceof common_1.ArrayExpression) {
-        return ast.items.map(transformFilter);
-    }
-    if (ast instanceof common_1.LogicalExpression) {
-        if (ast.op === 'or')
-            return { $or: ast.items.map(transformFilter) };
-        return { $and: ast.items.map(transformFilter) };
-    }
-    if (ast instanceof common_1.ParenthesesExpression) {
-        return transformFilter(ast.expression);
-    }
-    throw new Error(`${ast.type} is not implemented yet`);
+    throw new Error(`${ast.kind} is not implemented yet`);
 }
 exports.default = transformFilter;
+const wrapNot = (o, negative) => negative ? { $not: o } : o;

package/esm/mongo-collection-resource.js

@@ -1,9 +1,11 @@
 import { __decorate, __metadata } from "tslib";
-import { Collection, ResourceNotFoundError } from '@opra/common';
+import { Collection } from '@opra/common';
+import { CollectionResourceBase } from '@opra/core';
 import { MongoAdapter } from './mongo-adapter.js';
-export class MongoCollectionResource {
-    constructor() {
-        this.defaultLimit = 100;
+// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+export class MongoCollectionResource extends CollectionResourceBase {
+    constructor(options) {
+        super(options);
     }
     async create(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);
@@ -23,18 +25,12 @@ export class MongoCollectionResource {
     async get(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.findOne(prepared.filter, prepared.options);
-        if (!out)
-            throw new ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.findOne(prepared.filter, prepared.options);
     }
     async update(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.updateOne(prepared.filter, prepared.update, prepared.options);
-        if (!out)
-            throw new ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.updateOne(prepared.filter, prepared.update, prepared.options);
     }
     async updateMany(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);

package/esm/mongo-entity-service.js

@@ -1,11 +1,14 @@
 export class MongoEntityService {
-    constructor(collectionName, options) {
-        this.collectionName = collectionName;
+    constructor(arg0, arg1) {
+        const options = typeof arg0 === 'object' ? arg0 : arg1;
+        if (typeof arg0 === 'string')
+            this._collectionName = arg0;
         this.db = options?.db;
         this.defaultLimit = options?.defaultLimit || 10;
     }
     async count(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -19,7 +22,8 @@ export class MongoEntityService {
         }
     }
     async deleteOne(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -34,7 +38,8 @@ export class MongoEntityService {
         }
     }
     async deleteMany(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -49,7 +54,8 @@ export class MongoEntityService {
         }
     }
     async findOne(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session
@@ -62,35 +68,40 @@ export class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
         return out;
     }
     async find(filter, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             limit: options?.limit || this.defaultLimit,
             session: options?.session || this.session
         };
         const out = [];
+        let cursor;
         try {
-            const cursor = collection.find(filter, options);
-            let row;
-            while (row = await cursor.next()) {
-                if (this.onTransformRow)
-                    row = this.onTransformRow(row);
-                out.push(row);
+            cursor = collection.find(filter, options);
+            let obj;
+            while (out.length < this.defaultLimit && (obj = await cursor.next())) {
+                const v = this.transformData ? this.transformData(obj) : obj;
+                if (v)
+                    out.push(obj);
             }
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
+        finally {
+            if (cursor)
+                await cursor.close();
+        }
         return out;
     }
     async insertOne(doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         let out;
         options = {
             ...options,
@@ -105,14 +116,15 @@ export class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
+        if (this.transformData)
+            out = this.transformData(out);
         if (!out)
             throw new Error('"insertOne" operation returned no result!');
         return out;
     }
     async updateOne(filter, doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         let out;
         options = {
             ...options,
@@ -127,12 +139,13 @@ export class MongoEntityService {
             await this._onError(e);
             throw e;
         }
-        if (this.onTransformRow)
-            out = this.onTransformRow(out);
+        if (this.transformData)
+            out = this.transformData(out);
         return out;
     }
     async updateMany(filter, doc, options) {
-        const collection = (await this.getDatabase()).collection(this.collectionName);
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.session,
@@ -172,4 +185,14 @@ export class MongoEntityService {
             throw new Error(`Database not set!`);
         return this.db;
     }
+    async getCollection(db) {
+        if (!this._collectionName)
+            throw new Error('collectionName is not assigned');
+        return db.collection(this.getCollectionName());
+    }
+    getCollectionName() {
+        if (!this._collectionName)
+            throw new Error('collectionName is not defined');
+        return this._collectionName;
+    }
 }

package/esm/mongo-singleton-resource.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { ResourceNotFoundError, Singleton } from '@opra/common';
+import { Singleton } from '@opra/common';
 import { MongoAdapter } from './mongo-adapter.js';
 export class MongoSingletonResource {
     constructor() {
@@ -19,18 +19,12 @@ export class MongoSingletonResource {
     async get(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.findOne(prepared.filter, prepared.options);
-        if (!out)
-            throw new ResourceNotFoundError(service.collectionName);
-        return out;
+        return service.findOne(prepared.filter, prepared.options);
     }
     async update(ctx) {
         const prepared = MongoAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        const out = await service.updateOne(prepared.filter, prepared.update, prepared.options);
-        if (!out)
-            throw new ResourceNotFoundError(service.collectionName, prepared.filter._id);
-        return out;
+        return service.updateOne(prepared.filter, prepared.update, prepared.options);
     }
 }
 __decorate([

package/esm/transform-filter.js

@@ -1,93 +1,108 @@
-import { ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, parseFilter, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/common';
-export default function transformFilter(str) {
-    const ast = typeof str === 'string' ? parseFilter(str) : str;
+import '@opra/core';
+import { OpraFilter } from '@opra/common';
+const opMap = {
+    '=': '$eq',
+    '!=': '$ne',
+    '>': '$gt',
+    '>=': '$gte',
+    '<': '$lt',
+    '<=': '$lte',
+    'in': '$in',
+    '!in': '$nin',
+};
+export default function transformFilter(ast, negative) {
     if (!ast)
         return;
-    if (ast instanceof ComparisonExpression) {
-        const left = ast.left instanceof QualifiedIdentifier
-            ? ast.left.value
-            : transformFilter(ast.left);
-        const right = transformFilter(ast.right);
-        switch (ast.op) {
-            case '=':
+    if (ast instanceof OpraFilter.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof OpraFilter.NumberLiteral ||
+        ast instanceof OpraFilter.StringLiteral ||
+        ast instanceof OpraFilter.BooleanLiteral ||
+        ast instanceof OpraFilter.NullLiteral ||
+        ast instanceof OpraFilter.DateLiteral ||
+        ast instanceof OpraFilter.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof OpraFilter.ArrayExpression) {
+        return ast.items.map(x => transformFilter(x, negative));
+    }
+    if (ast instanceof OpraFilter.NegativeExpression) {
+        return transformFilter(ast.expression, !negative);
+    }
+    if (ast instanceof OpraFilter.LogicalExpression) {
+        if (ast.op === 'or')
+            return { $or: ast.items.map(x => transformFilter(x, negative)) };
+        return { $and: ast.items.map(x => transformFilter(x, negative)) };
+    }
+    if (ast instanceof OpraFilter.ParenthesizedExpression) {
+        return transformFilter(ast.expression, negative);
+    }
+    if (ast instanceof OpraFilter.ComparisonExpression) {
+        const left = transformFilter(ast.left, negative);
+        if (ast.right instanceof OpraFilter.QualifiedIdentifier) {
+            const op = opMap[ast.op];
+            if (op)
+                return { $expr: { [op]: ["$" + left, "$" + ast.right.value] } };
+            /* istanbul ignore next */
+            throw new Error(`Invalid filter query.`);
+        }
+        let right = transformFilter(ast.right);
+        if (right == null) {
+            const op = ast.op === '='
+                ? (negative ? '!=' : '=')
+                : (negative ? '=' : '!=');
+            if (op === '=')
+                return { $or: [{ [left]: null }, { [left]: { $exists: false } }] };
+            if (op === '!=')
+                return { $and: [{ $ne: { [left]: null } }, { [left]: { $exists: true } }] };
+        }
+        const mngOp = opMap[ast.op];
+        if (mngOp) {
+            if (ast.op === 'in' || ast.op === '!in')
+                right = Array.isArray(right) ? right : [right];
+            if (ast.op === '=' && !negative)
                 return { [left]: right };
-            case '!=':
-                return { [left]: { $ne: right } };
-            case '>':
-                return { [left]: { $gt: right } };
-            case '>=':
-                return { [left]: { $gte: right } };
-            case '<':
-                return { [left]: { $lt: right } };
-            case '<=':
-                return { [left]: { $lte: right } };
-            case 'in':
-                return { [left]: { $in: Array.isArray(right) ? right : [right] } };
-            case '!in':
-                return { [left]: { $nin: Array.isArray(right) ? right : [right] } };
+            return { [left]: wrapNot({ [mngOp]: right }, negative) };
+        }
+        switch (ast.op) {
             case 'like':
                 return {
-                    [left]: {
+                    [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
                             $caseSensitive: true
                         }
-                    }
+                    }, negative)
                 };
             case 'ilike':
                 return {
-                    [left]: {
+                    [left]: wrapNot({
                         $text: {
                             $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
                         }
-                    }
+                    }, negative)
                 };
             case '!like':
                 return {
-                    [left]: {
-                        $not: {
-                            $text: {
-                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
-                                $caseSensitive: true
-                            }
+                    [left]: wrapNot({
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                            $caseSensitive: true
                         }
-                    }
+                    }, !negative)
                 };
             case '!ilike':
                 return {
-                    [left]: {
-                        $not: {
-                            $text: {
-                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
-                            }
+                    [left]: wrapNot({
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
                         }
-                    }
+                    }, !negative)
                 };
-            default:
-                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
         }
+        throw new Error(`Unimplemented ComparisonExpression operation (right side is ${ast.right.kind})`);
     }
-    if (ast instanceof QualifiedIdentifier) {
-        return ast.value;
-    }
-    if (ast instanceof NumberLiteral ||
-        ast instanceof StringLiteral ||
-        ast instanceof BooleanLiteral ||
-        ast instanceof NullLiteral ||
-        ast instanceof DateLiteral ||
-        ast instanceof TimeLiteral) {
-        return ast.value;
-    }
-    if (ast instanceof ArrayExpression) {
-        return ast.items.map(transformFilter);
-    }
-    if (ast instanceof LogicalExpression) {
-        if (ast.op === 'or')
-            return { $or: ast.items.map(transformFilter) };
-        return { $and: ast.items.map(transformFilter) };
-    }
-    if (ast instanceof ParenthesesExpression) {
-        return transformFilter(ast.expression);
-    }
-    throw new Error(`${ast.type} is not implemented yet`);
+    throw new Error(`${ast.kind} is not implemented yet`);
 }
+const wrapNot = (o, negative) => negative ? { $not: o } : o;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/mongodb",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -29,12 +29,12 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^7.6.0",
-    "mongodb": "^5.3.0",
+    "mongodb": "^5.4.0",
     "ts-gems": "^2.3.0"
   },
   "peerDependencies": {
-    "@opra/common": "^0.17.1",
-    "@opra/core": "^0.17.1",
+    "@opra/common": "^0.17.2",
+    "@opra/core": "^0.17.2",
     "mongodb": ">=4.x.x"
   },
   "type": "module",

package/types/mongo-collection-resource.d.ts

@@ -1,14 +1,19 @@
 import mongodb from 'mongodb';
+import { Maybe } from 'ts-gems';
 import { PartialOutput } from '@opra/common';
-import { RequestContext } from '@opra/core';
+import { CollectionResourceBase, RequestContext } from '@opra/core';
 import { MongoEntityService } from './mongo-entity-service.js';
-export declare abstract class MongoCollectionResource<T extends mongodb.Document, TOutput = PartialOutput<T>> {
-    defaultLimit: number;
+export declare namespace MongoCollectionResource {
+    interface Options extends CollectionResourceBase.Options {
+    }
+}
+export declare abstract class MongoCollectionResource<T extends mongodb.Document, TOutput = PartialOutput<T>> extends CollectionResourceBase {
+    constructor(options?: MongoCollectionResource.Options);
     create(ctx: RequestContext): Promise<TOutput>;
     delete(ctx: RequestContext): Promise<number>;
     deleteMany(ctx: RequestContext): Promise<number>;
-    get(ctx: RequestContext): Promise<TOutput>;
-    update(ctx: RequestContext): Promise<TOutput>;
+    get(ctx: RequestContext): Promise<Maybe<TOutput>>;
+    update(ctx: RequestContext): Promise<Maybe<TOutput>>;
     updateMany(ctx: RequestContext): Promise<number>;
     findMany(ctx: RequestContext): Promise<TOutput[]>;
     abstract getService(ctx: RequestContext): MongoEntityService<T, TOutput> | Promise<MongoEntityService<T, TOutput>>;

package/types/mongo-entity-service.d.ts

@@ -8,11 +8,12 @@ export declare namespace MongoEntityService {
     }
 }
 export declare class MongoEntityService<T extends mongodb.Document, TOutput = PartialOutput<T>> {
-    readonly collectionName: string;
+    protected _collectionName: string;
     context: RequestContext;
     defaultLimit: number;
     db?: mongodb.Db;
     session?: mongodb.ClientSession;
+    constructor(options?: MongoEntityService.Options);
     constructor(collectionName: string, options?: MongoEntityService.Options);
     count(filter?: mongodb.Filter<T>, options?: mongodb.CountOptions): Promise<number>;
     deleteOne(filter?: mongodb.Filter<T>, options?: mongodb.DeleteOptions): Promise<number>;
@@ -25,6 +26,8 @@ export declare class MongoEntityService<T extends mongodb.Document, TOutput = Pa
     with(context: RequestContext, db?: mongodb.Db, session?: mongodb.ClientSession): MongoEntityService<T, TOutput>;
     protected _onError(error: unknown): Promise<void>;
     protected getDatabase(): mongodb.Db | Promise<mongodb.Db>;
+    protected getCollection(db: mongodb.Db): Promise<mongodb.Collection<T>>;
+    protected getCollectionName(): string;
     protected onError?(error: unknown): void | Promise<void>;
-    protected onTransformRow?(row: mongodb.WithId<T>): mongodb.WithId<T>;
+    protected transformData?(row: TOutput): TOutput;
 }

package/types/mongo-singleton-resource.d.ts

@@ -1,4 +1,5 @@
 import mongodb from 'mongodb';
+import { Maybe } from 'ts-gems';
 import { PartialOutput } from '@opra/common';
 import { RequestContext } from '@opra/core';
 import { MongoEntityService } from './mongo-entity-service.js';
@@ -6,7 +7,7 @@ export declare abstract class MongoSingletonResource<T extends mongodb.Document,
     defaultLimit: number;
     create(ctx: RequestContext): Promise<TOutput>;
     delete(ctx: RequestContext): Promise<number>;
-    get(ctx: RequestContext): Promise<TOutput>;
-    update(ctx: RequestContext): Promise<TOutput>;
+    get(ctx: RequestContext): Promise<Maybe<TOutput>>;
+    update(ctx: RequestContext): Promise<Maybe<TOutput>>;
     abstract getService(ctx: RequestContext): MongoEntityService<T, TOutput> | Promise<MongoEntityService<T, TOutput>>;
 }

package/types/transform-filter.d.ts

@@ -1,2 +1,3 @@
-import { Expression } from '@opra/common';
-export default function transformFilter(str: string | Expression | undefined): any;
+import '@opra/core';
+import { OpraFilter } from '@opra/common';
+export default function transformFilter(ast: OpraFilter.Expression | undefined, negative?: boolean): any;