@opra/mongodb 0.16.0

package/cjs/transform-projection.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._transformExclusionProjection = exports._transformInclusionProjection = void 0;
+const common_1 = require("@opra/common");
+function transformProjection(dataType, args) {
+    const out = {};
+    // omitExclusiveFields(dataType, out);
+    const pick = args.pick && (0, common_1.pathToObjectTree)(args.include ? [...args.pick, ...args.include] : args.pick);
+    const include = !args.pick && args.include && (0, common_1.pathToObjectTree)(args.include);
+    const omit = args.omit && (0, common_1.pathToObjectTree)(args.omit);
+    if (pick || include) {
+        _transformInclusionProjection(dataType, out, pick, include, omit);
+    }
+    else
+        _transformExclusionProjection(dataType, out, omit, !omit);
+    return Object.keys(out).length ? out : undefined;
+}
+exports.default = transformProjection;
+function _transformInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
+    defaultFields = defaultFields ?? !pick;
+    let n;
+    for (const [k, f] of dataType.fields.entries()) {
+        if (omit?.[k] === true)
+            continue;
+        n = (defaultFields && !f.exclusive) ||
+            pick === true || pick?.[k] || include === true || include?.[k];
+        if (n) {
+            if (f.type instanceof common_1.ComplexType && (typeof n === 'object' || typeof omit?.[k] === 'object')) {
+                target[k] = {};
+                _transformInclusionProjection(f.type, target[k], pick?.[k] || include?.[k], undefined, omit?.[k], defaultFields);
+                continue;
+            }
+            target[k] = 1;
+        }
+    }
+}
+exports._transformInclusionProjection = _transformInclusionProjection;
+function _transformExclusionProjection(dataType, target, omit, omitExclusiveFields) {
+    let n;
+    for (const [k, f] of dataType.fields.entries()) {
+        n = omit?.[k] || (omitExclusiveFields && f.exclusive);
+        if (n) {
+            if (f.type instanceof common_1.ComplexType && typeof n === 'object') {
+                target[k] = {};
+                _transformExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
+                continue;
+            }
+            target[k] = 0;
+        }
+    }
+}
+exports._transformExclusionProjection = _transformExclusionProjection;

package/cjs/transform-sort.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformSort(sort) {
+    if (!(sort && sort.length))
+        return;
+    const out = {};
+    if (sort)
+        sort.forEach(k => {
+            if (k.startsWith('-'))
+                out[k.substring(1)] = -1;
+            else if (k.startsWith('+'))
+                out[k.substring(1)] = 1;
+            else
+                out[k] = 1;
+        });
+    return out;
+}
+exports.default = transformSort;

package/esm/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./mongo-adapter.js"), exports);
+tslib_1.__exportStar(require("./mongo-collection-resource.js"), exports);
+tslib_1.__exportStar(require("./mongo-entity-service.js"), exports);
+tslib_1.__exportStar(require("./mongo-singleton-resource.js"), exports);

package/esm/mongo-adapter.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAdapter = void 0;
+const tslib_1 = require("tslib");
+const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
+const lodash_omitby_1 = tslib_1.__importDefault(require("lodash.omitby"));
+const common_1 = require("@opra/common");
+const transform_filter_js_1 = tslib_1.__importDefault(require("./transform-filter.js"));
+const transform_key_values_js_1 = tslib_1.__importDefault(require("./transform-key-values.js"));
+const transform_patch_js_1 = tslib_1.__importDefault(require("./transform-patch.js"));
+const transform_projection_js_1 = tslib_1.__importDefault(require("./transform-projection.js"));
+const transform_sort_js_1 = tslib_1.__importDefault(require("./transform-sort.js"));
+var MongoAdapter;
+(function (MongoAdapter) {
+    MongoAdapter.transformFilter = transform_filter_js_1.default;
+    MongoAdapter.transformKeyValues = transform_key_values_js_1.default;
+    MongoAdapter.transformPatch = transform_patch_js_1.default;
+    MongoAdapter.transformProjection = transform_projection_js_1.default;
+    MongoAdapter.transformSort = transform_sort_js_1.default;
+    function transformRequest(request) {
+        const { resource } = request;
+        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
+            const { args, operation } = request;
+            let options = {};
+            let filter;
+            if (operation === 'create' || operation === 'update' ||
+                operation === 'get' || operation === 'findMany') {
+                options.projection = MongoAdapter.transformProjection(resource.type, args);
+            }
+            if (resource instanceof common_1.Collection &&
+                (operation === 'delete' || operation === 'get' || operation === 'update')) {
+                filter = MongoAdapter.transformKeyValues(resource, args.key);
+            }
+            if (args.filter) {
+                const f = MongoAdapter.transformFilter(args.filter);
+                filter = filter ? { $and: [filter, f] } : f;
+            }
+            if (operation === 'findMany') {
+                options.sort = args.sort?.length ? args.sort : undefined;
+                options.limit = args.limit;
+                options.skip = args.skip;
+                options.distinct = args.distinct;
+                options.count = args.count;
+            }
+            options = (0, lodash_omitby_1.default)(options, lodash_isnil_1.default);
+            switch (operation) {
+                case 'create': {
+                    return {
+                        method: 'insertOne',
+                        data: args.data,
+                        options,
+                        args: [args.data, options]
+                    };
+                }
+                case 'delete':
+                case 'deleteMany': {
+                    return {
+                        method: (operation === 'delete' ? 'deleteOne' : 'deleteMany'),
+                        filter,
+                        options,
+                        args: [filter, options]
+                    };
+                }
+                case 'get': {
+                    return {
+                        method: 'findOne',
+                        filter,
+                        options,
+                        args: [filter, options]
+                    };
+                }
+                case 'findMany': {
+                    const out = {
+                        method: 'find',
+                        filter,
+                        options,
+                        args: [filter, options]
+                    };
+                    if (args.count)
+                        out.count = args.count;
+                    return out;
+                }
+                case 'update': {
+                    const update = MongoAdapter.transformPatch(args.data);
+                    filter = filter || {};
+                    return {
+                        method: 'updateOne',
+                        filter,
+                        update,
+                        options,
+                        args: [filter, update, options]
+                    };
+                }
+                case 'updateMany': {
+                    const update = MongoAdapter.transformPatch(args.data);
+                    return {
+                        method: 'updateMany',
+                        filter,
+                        update,
+                        options,
+                        args: [filter, update, options]
+                    };
+                }
+            }
+        }
+        throw new TypeError(`Unimplemented request kind (${request.resourceKind}.${request.operation})`);
+    }
+    MongoAdapter.transformRequest = transformRequest;
+})(MongoAdapter = exports.MongoAdapter || (exports.MongoAdapter = {}));

package/esm/mongo-collection-resource.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCollectionResource = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const mongo_adapter_js_1 = require("./mongo-adapter.js");
+class MongoCollectionResource {
+    constructor() {
+        this.defaultLimit = 100;
+    }
+    async create(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.insertOne(prepared.data, prepared.options);
+    }
+    async delete(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.deleteOne(prepared.filter, prepared.options);
+    }
+    async deleteMany(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.deleteMany(prepared.filter, prepared.options);
+    }
+    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;
+    }
+    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;
+    }
+    async updateMany(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.updateMany(prepared.filter, prepared.update, prepared.options);
+    }
+    async search(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        if (prepared.count) {
+            const [items, count] = await Promise.all([
+                service.find(prepared.filter, prepared.options),
+                service.count(prepared.filter, prepared.options)
+            ]);
+            ctx.response.count = count;
+            return items;
+        }
+        return service.find(prepared.filter, prepared.options);
+    }
+}
+tslib_1.__decorate([
+    common_1.Collection.Create(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "create", null);
+tslib_1.__decorate([
+    common_1.Collection.Delete(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "delete", null);
+tslib_1.__decorate([
+    common_1.Collection.DeleteMany(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "deleteMany", null);
+tslib_1.__decorate([
+    common_1.Collection.Get(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "get", null);
+tslib_1.__decorate([
+    common_1.Collection.Update(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "update", null);
+tslib_1.__decorate([
+    common_1.Collection.UpdateMany(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "updateMany", null);
+tslib_1.__decorate([
+    common_1.Collection.FindMany(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoCollectionResource.prototype, "search", null);
+exports.MongoCollectionResource = MongoCollectionResource;

package/esm/mongo-entity-service.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEntityService = void 0;
+class MongoEntityService {
+    constructor(collectionName, options) {
+        this.collectionName = collectionName;
+        this.db = options?.db;
+        this.defaultLimit = options?.defaultLimit || 10;
+    }
+    async count(filter, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            return await collection.count(filter, options) || 0;
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async deleteOne(filter, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            const r = await collection.deleteOne(filter, options);
+            return r.deletedCount;
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async deleteMany(filter, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            const r = await collection.deleteMany(filter, options);
+            return r.deletedCount;
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async findOne(filter, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        let out;
+        try {
+            out = await collection.findOne(filter, options);
+        }
+        catch (e) {
+            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);
+        options = {
+            ...options,
+            limit: options?.limit || this.defaultLimit,
+            session: options?.session || this.session
+        };
+        const out = [];
+        try {
+            const cursor = collection.find(filter, options);
+            let row;
+            while (row = await cursor.next()) {
+                if (this.onTransformRow)
+                    row = this.onTransformRow(row);
+                out.push(row);
+            }
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        return out;
+    }
+    async insertOne(doc, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        let out;
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            const r = await collection.insertOne(doc, options);
+            if (r.insertedId)
+                out = await collection.findOne({ _id: r.insertedId }, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (this.onTransformRow)
+            out = this.onTransformRow(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);
+        let out;
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            const r = await collection.updateOne(filter, doc, options);
+            if (r.matchedCount)
+                out = await collection.findOne((r.upsertedId ? { _id: r.upsertedId } : filter), options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (this.onTransformRow)
+            out = this.onTransformRow(out);
+        return out;
+    }
+    async updateMany(filter, doc, options) {
+        const collection = (await this.getDatabase()).collection(this.collectionName);
+        options = {
+            ...options,
+            session: options?.session || this.session,
+            upsert: false
+        };
+        try {
+            const r = await collection.updateMany(filter, doc, options);
+            return r.matchedCount;
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    with(context, db, session) {
+        if (this.context === context && this.db === db && this.session === session)
+            return this;
+        const instance = { context };
+        // Should reset session if db changed
+        if (db) {
+            instance.db = db;
+            instance.session = session;
+        }
+        if (session)
+            instance.session = session;
+        Object.setPrototypeOf(instance, this);
+        return instance;
+    }
+    async _onError(error) {
+        if (this.onError)
+            await this.onError(error);
+    }
+    getDatabase() {
+        if (!this.context)
+            throw new Error(`Context not set!`);
+        if (!this.db)
+            throw new Error(`Database not set!`);
+        return this.db;
+    }
+}
+exports.MongoEntityService = MongoEntityService;

package/esm/mongo-singleton-resource.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoSingletonResource = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const mongo_adapter_js_1 = require("./mongo-adapter.js");
+class MongoSingletonResource {
+    constructor() {
+        this.defaultLimit = 100;
+    }
+    async create(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        await service.deleteMany();
+        return service.insertOne(prepared.data, prepared.options);
+    }
+    async delete(ctx) {
+        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.deleteOne(prepared.filter, prepared.options);
+    }
+    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;
+    }
+    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;
+    }
+}
+tslib_1.__decorate([
+    common_1.Singleton.Create(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoSingletonResource.prototype, "create", null);
+tslib_1.__decorate([
+    common_1.Singleton.Delete(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoSingletonResource.prototype, "delete", null);
+tslib_1.__decorate([
+    common_1.Singleton.Get(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoSingletonResource.prototype, "get", null);
+tslib_1.__decorate([
+    common_1.Singleton.Update(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], MongoSingletonResource.prototype, "update", null);
+exports.MongoSingletonResource = MongoSingletonResource;

package/esm/transform-filter.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+function transformFilter(str) {
+    const ast = typeof str === 'string' ? (0, common_1.parseFilter)(str) : str;
+    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 '=':
+                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] } };
+            case 'like':
+                return {
+                    [left]: {
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                            $caseSensitive: true
+                        }
+                    }
+                };
+            case 'ilike':
+                return {
+                    [left]: {
+                        $text: {
+                            $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
+                        }
+                    }
+                };
+            case '!like':
+                return {
+                    [left]: {
+                        $not: {
+                            $text: {
+                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"',
+                                $caseSensitive: true
+                            }
+                        }
+                    }
+                };
+            case '!ilike':
+                return {
+                    [left]: {
+                        $not: {
+                            $text: {
+                                $search: '\\"' + right.replace(/\\"/, '"') + '\\"'
+                            }
+                        }
+                    }
+                };
+            default:
+                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+        }
+    }
+    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`);
+}
+exports.default = transformFilter;

package/esm/transform-key-values.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformKeyValues(resource, keyValues) {
+    const { primaryKey } = resource;
+    if (primaryKey.length > 1) {
+        const query = {};
+        primaryKey.forEach((k, i) => {
+            query[k] = typeof keyValues === 'object' ? keyValues[k] : keyValues[i];
+        });
+        return query;
+    }
+    return { [primaryKey[0]]: keyValues };
+}
+exports.default = transformKeyValues;

package/esm/transform-patch.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformPatch(doc) {
+    const trg = {};
+    _transformPatch(doc, trg);
+    return trg;
+}
+exports.default = transformPatch;
+function _transformPatch(src, trg = {}, path = '') {
+    let fieldName;
+    for (const [k, v] of Object.entries(src)) {
+        fieldName = k.startsWith('*') ? k.substring(1) : k;
+        const key = path ? path + '.' + fieldName : fieldName;
+        if (v == null) {
+            trg.$unset = trg.$unset || {};
+            trg.$unset[key] = '';
+            continue;
+        }
+        if (v && typeof v === 'object') {
+            // If field name starts with "*", do "replace" operation except "merge"
+            if (!k.startsWith('*')) {
+                _transformPatch(v, trg, key);
+                continue;
+            }
+        }
+        trg.$set = trg.$set || {};
+        trg.$set[key] = v;
+    }
+    return trg;
+}