@opra/sqb 0.15.0 → 0.16.0

package/cjs/augmentation/document-factory.augmentation.js

@@ -24,6 +24,8 @@ common_1.DocumentFactory.prototype.extractFieldSchema = async function (target,
         }
     }
     else if (sqbField.kind === 'column') {
+        if (typeof sqbField.enum === 'object')
+            metadata.enum = sqbField.enum;
         if (sqbField.type && Reflect.hasMetadata(common_1.METADATA_KEY, sqbField.type)) {
             target.type = sqbField.type;
         }

package/cjs/sqb-adapter.js

@@ -4,209 +4,112 @@ exports.SQBAdapter = 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 convert_filter_js_1 = require("./convert-filter.js");
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+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"));
 var SQBAdapter;
 (function (SQBAdapter) {
-    SQBAdapter.parseFilter = convert_filter_js_1.convertFilter;
-    function parseCollectionCreateRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'create'))
-            throw new TypeError('"Request" is not a "CollectionCreateRequest"');
-        const { args } = request;
-        return {
-            method: 'create',
-            data: args.data,
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionCreateRequest = parseCollectionCreateRequest;
-    function parseCollectionDeleteRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'delete'))
-            throw new TypeError('"Request" is not a "CollectionDeleteRequest"');
-        const { args } = request;
-        return {
-            method: 'destroy',
-            key: args.key,
-            options: {}
-        };
-    }
-    SQBAdapter.parseCollectionDeleteRequest = parseCollectionDeleteRequest;
-    function parseCollectionDeleteManyRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'deleteMany'))
-            throw new TypeError('"Request" is not a "CollectionDeleteManyRequest"');
-        const { args } = request;
-        return {
-            method: 'destroyAll',
-            options: (0, lodash_omitby_1.default)({
-                filter: SQBAdapter.parseFilter(args.filter)
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionDeleteManyRequest = parseCollectionDeleteManyRequest;
-    function parseCollectionGetRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'get'))
-            throw new TypeError('"Request" is not a "CollectionGetRequest"');
-        const { args } = request;
-        return {
-            method: 'findByPk',
-            key: args.key,
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionGetRequest = parseCollectionGetRequest;
-    function parseCollectionUpdateRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'update'))
-            throw new TypeError('"Request" is not a "CollectionUpdateRequest"');
-        const { args } = request;
-        return {
-            method: 'update',
-            key: args.key,
-            data: args.data,
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionUpdateRequest = parseCollectionUpdateRequest;
-    function parseCollectionUpdateManyRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'updateMany'))
-            throw new TypeError('"Request" is not a "CollectionUpdateManyRequest"');
-        const { args } = request;
-        return {
-            method: 'updateAll',
-            data: args.data,
-            options: (0, lodash_omitby_1.default)({
-                filter: SQBAdapter.parseFilter(args.filter)
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionUpdateManyRequest = parseCollectionUpdateManyRequest;
-    function parseCollectionSearchRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Collection' && request.operation === 'search'))
-            throw new TypeError('"Request" is not a "CollectionSearchRequest"');
-        const { args } = request;
-        return {
-            method: 'findAll',
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-                sort: args.sort?.length ? args.sort : undefined,
-                limit: args.limit,
-                offset: args.skip,
-                distinct: args.distinct,
-                count: args.count,
-                filter: SQBAdapter.parseFilter(args.filter)
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseCollectionSearchRequest = parseCollectionSearchRequest;
-    function parseSingletonGetRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Singleton' && request.operation === 'get'))
-            throw new TypeError('"Request" is not a "SingletonGetRequest"');
-        const { args } = request;
-        return {
-            method: 'findOne',
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseSingletonGetRequest = parseSingletonGetRequest;
-    function parseSingletonCreateRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Singleton' && request.operation === 'create'))
-            throw new TypeError('"Request" is not a "SingletonCreateRequest"');
-        const { args } = request;
-        return {
-            method: 'create',
-            data: args.data,
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseSingletonCreateRequest = parseSingletonCreateRequest;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    function parseSingletonDeleteRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Singleton' && request.operation === 'delete'))
-            throw new TypeError('"Request" is not a "SingletonDeleteRequest"');
-        return {
-            method: 'destroyAll',
-            options: {},
-        };
-    }
-    SQBAdapter.parseSingletonDeleteRequest = parseSingletonDeleteRequest;
-    function parseSingletonUpdateRequest(request) {
-        /* istanbul ignore next */
-        if (!(request.resourceKind === 'Singleton' && request.operation === 'update'))
-            throw new TypeError('"Request" is not a "SingletonUpdateRequest"');
-        const { args } = request;
-        return {
-            method: 'updateAll',
-            data: args.data,
-            options: (0, lodash_omitby_1.default)({
-                pick: args.pick?.length ? args.pick : undefined,
-                omit: args.omit?.length ? args.omit : undefined,
-                include: args.include?.length ? args.include : undefined,
-            }, lodash_isnil_1.default)
-        };
-    }
-    SQBAdapter.parseSingletonUpdateRequest = parseSingletonUpdateRequest;
-    function parseRequest(request) {
-        if (request.resourceKind === 'Collection') {
-            switch (request.operation) {
-                case 'create':
-                    return parseCollectionCreateRequest(request);
-                case 'get':
-                    return parseCollectionGetRequest(request);
-                case 'delete':
-                    return parseCollectionDeleteRequest(request);
-                case 'deleteMany':
-                    return parseCollectionDeleteManyRequest(request);
-                case 'update':
-                    return parseCollectionUpdateRequest(request);
-                case 'updateMany':
-                    return parseCollectionUpdateManyRequest(request);
-                case 'search':
-                    return parseCollectionSearchRequest(request);
+    SQBAdapter.transformFilter = transform_filter_js_1.default;
+    SQBAdapter.transformKeyValues = transform_key_values_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 = {};
+            const entityMetadata = connect_1.EntityMetadata.get(resource.type.ctor);
+            if (!entityMetadata)
+                throw new Error(`Type class "${resource.type.ctor}" is not an SQB entity`);
+            if (resource instanceof common_1.Collection) {
+                const primaryIndex = entityMetadata.indexes.find(x => x.primary);
+                // Check if resource primary keys are same with entity
+                const primaryKeys = [...(primaryIndex && primaryIndex.columns) || []];
+                if (primaryKeys.sort().join() !== [...resource.primaryKey].sort().join())
+                    throw new Error('Resource primaryKey definition differs from SQB Entity primaryKey definition');
             }
-        }
-        else if (request.resourceKind === 'Singleton') {
-            switch (request.operation) {
-                case 'create':
-                    return parseSingletonCreateRequest(request);
-                case 'delete':
-                    return parseSingletonDeleteRequest(request);
-                case 'get':
-                    return parseSingletonGetRequest(request);
-                case 'update':
-                    return parseSingletonUpdateRequest(request);
+            if (operation === 'create' || operation === 'update' ||
+                operation === 'get' || operation === 'findMany') {
+                options.pick = args.pick?.length ? args.pick : undefined;
+                options.omit = args.omit?.length ? args.omit : undefined;
+                options.include = args.include?.length ? args.include : undefined;
+            }
+            if (args.filter) {
+                options.filter = SQBAdapter.transformFilter(args.filter);
+            }
+            if (operation === 'findMany') {
+                options.sort = args.sort?.length ? args.sort : undefined;
+                options.limit = args.limit;
+                options.offset = args.skip;
+                options.distinct = args.distinct;
+                options.count = args.count;
+            }
+            options = (0, lodash_omitby_1.default)(options, lodash_isnil_1.default);
+            if (operation === 'create') {
+                return {
+                    method: 'create',
+                    data: args.data,
+                    options,
+                    args: [args.data, options]
+                };
+            }
+            if (operation === 'deleteMany' || (operation === 'delete' && resource instanceof common_1.Singleton)) {
+                return {
+                    method: 'deleteMany',
+                    options,
+                    args: [options]
+                };
+            }
+            if (operation === 'delete') {
+                return {
+                    method: 'delete',
+                    key: args.key,
+                    options,
+                    args: [args.key, options]
+                };
+            }
+            if (operation === 'get') {
+                if (resource instanceof common_1.Singleton)
+                    return {
+                        method: 'findOne',
+                        options,
+                        args: [options]
+                    };
+                return {
+                    method: 'find',
+                    key: args.key,
+                    options,
+                    args: [args.key, options]
+                };
+            }
+            if (operation === 'findMany') {
+                const out = {
+                    method: 'findMany',
+                    options,
+                    args: [options]
+                };
+                if (args.count)
+                    out.count = args.count;
+                return out;
+            }
+            if (operation === 'updateMany' || (operation === 'update' && resource instanceof common_1.Singleton)) {
+                return {
+                    method: 'updateMany',
+                    data: args.data,
+                    options,
+                    args: [args.data, options]
+                };
+            }
+            if (operation === 'update') {
+                return {
+                    method: 'update',
+                    key: args.key,
+                    data: args.data,
+                    options,
+                    args: [args.key, args.data, options]
+                };
             }
         }
-        throw new Error(`Unimplemented request method "${request.method}"`);
+        throw new Error(`Unimplemented request method "${request.operation}"`);
     }
-    SQBAdapter.parseRequest = parseRequest;
+    SQBAdapter.transformRequest = transformRequest;
 })(SQBAdapter = exports.SQBAdapter || (exports.SQBAdapter = {}));

package/cjs/sqb-collection-resource.js

@@ -6,37 +6,37 @@ const common_1 = require("@opra/common");
 const sqb_adapter_js_1 = require("./sqb-adapter.js");
 class SqbCollectionResource {
     async create(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionCreateRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
         return service.create(ctx, prepared.data, prepared.options);
     }
     async delete(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionDeleteRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        return service.destroy(ctx, prepared.key, prepared.options);
+        return service.delete(ctx, prepared.key, prepared.options);
     }
     async deleteMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionDeleteManyRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        return service.destroyAll(ctx, prepared.options);
+        return service.deleteMany(ctx, prepared.options);
     }
-    async get(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionGetRequest(ctx.request);
+    async find(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        return service.findByPk(ctx, prepared.key, prepared.options);
+        return service.find(ctx, prepared.key, prepared.options);
     }
     async update(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionUpdateRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
         return service.update(ctx, prepared.key, prepared.data, prepared.options);
     }
     async updateMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionUpdateManyRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        return service.updateAll(ctx, prepared.data, prepared.options);
+        return service.updateMany(ctx, prepared.data, prepared.options);
     }
     async search(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.parseCollectionSearchRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
         if (prepared.options.count) {
             const [items, count] = await Promise.all([
@@ -51,43 +51,43 @@ class SqbCollectionResource {
     }
 }
 tslib_1.__decorate([
-    common_1.Collection.CreateOperation(),
+    common_1.Collection.Create(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], SqbCollectionResource.prototype, "create", null);
 tslib_1.__decorate([
-    common_1.Collection.DeleteOperation(),
+    common_1.Collection.Delete(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], SqbCollectionResource.prototype, "delete", null);
 tslib_1.__decorate([
-    common_1.Collection.DeleteManyOperation(),
+    common_1.Collection.DeleteMany(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], SqbCollectionResource.prototype, "deleteMany", null);
 tslib_1.__decorate([
-    common_1.Collection.GetOperation(),
+    common_1.Collection.Get(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
-], SqbCollectionResource.prototype, "get", null);
+], SqbCollectionResource.prototype, "find", null);
 tslib_1.__decorate([
-    common_1.Collection.UpdateOperation(),
+    common_1.Collection.Update(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], SqbCollectionResource.prototype, "update", null);
 tslib_1.__decorate([
-    common_1.Collection.UpdateManyOperation(),
+    common_1.Collection.UpdateMany(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)
 ], SqbCollectionResource.prototype, "updateMany", null);
 tslib_1.__decorate([
-    common_1.Collection.SearchOperation(),
+    common_1.Collection.FindMany(),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [Object]),
     tslib_1.__metadata("design:returntype", Promise)

package/cjs/sqb-entity-service.js

@@ -3,106 +3,109 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqbEntityService = void 0;
 const connect_1 = require("@sqb/connect");
 class SqbEntityService {
-    constructor(resourceType) {
-        this.resourceType = resourceType;
-        const metadata = connect_1.EntityMetadata.get(resourceType);
+    constructor(typeClass, options) {
+        this.typeClass = typeClass;
+        const metadata = connect_1.EntityMetadata.get(typeClass);
         if (!metadata)
-            throw new TypeError(`You must provide an SQB entity class`);
-        this._entityMetadata = metadata;
+            throw new TypeError(`Class ${typeClass} is not decorated with $Entity() decorator`);
+        this.db = options?.db;
+        this.defaultLimit = options?.defaultLimit || 10;
     }
-    async create(context, data, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
-        let out;
+    async count(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         try {
-            out = await repo.create(data, options);
+            return await repo.count(options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
-        if (out && this.onTransformRow)
-            out = this.onTransformRow(context, out, 'create');
-        return out;
     }
-    async count(context, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+    async create(context, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        let out;
         try {
-            return await repo.count(options);
+            out = await repo.create(data, options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
+        if (out && this.onTransformRow)
+            out = this.onTransformRow(out);
+        if (!out)
+            throw new Error('"create" operation returned no result!');
+        return out;
     }
-    async destroy(context, keyValue, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+    async delete(context, keyValue, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         try {
-            return await repo.destroy(keyValue, options);
+            return await repo.delete(keyValue, options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
     }
-    async destroyAll(context, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+    async deleteMany(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         try {
-            return await repo.destroyAll(options);
+            return await repo.deleteMany(options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
     }
-    async findByPk(context, keyValue, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+    async find(context, keyValue, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         let out;
         try {
-            out = await repo.findByPk(keyValue, options);
+            out = await repo.find(keyValue, options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(context, out, 'read');
+            out = this.onTransformRow(out);
         return out;
     }
     async findOne(context, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         let out;
         try {
             out = await repo.findOne(options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(context, out, 'read');
+            out = this.onTransformRow(out);
         return out;
     }
     async findAll(context, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         let items;
         try {
             items = await repo.findAll(options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
         if (items.length && this.onTransformRow) {
             const newItems = [];
             for (const item of items) {
-                const v = this.onTransformRow(context, item, 'read');
+                const v = this.onTransformRow(item);
                 if (v)
                     newItems.push(v);
             }
@@ -110,35 +113,64 @@ class SqbEntityService {
         }
         return items;
     }
+    async exists(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        try {
+            return await repo.exists(options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
     async update(context, keyValue, data, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         let out;
         try {
             out = await repo.update(keyValue, data, options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(context, out, 'update');
+            out = this.onTransformRow(out);
         return out;
     }
-    async updateAll(context, data, options) {
-        const conn = await this.getConnection(context);
-        const repo = conn.getRepository(this.resourceType);
+    async updateMany(context, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
         try {
-            return await repo.updateAll(data, options);
+            return await repo.updateMany(data, options);
         }
         catch (e) {
-            await this._onError(context, e);
+            await this._onError(e);
             throw e;
         }
     }
-    async _onError(context, error) {
+    with(context, db) {
+        if (this.context === context && this.db === db)
+            return this;
+        const instance = { context };
+        // Should reset session if db changed
+        if (db) {
+            instance.db = db;
+        }
+        Object.setPrototypeOf(instance, this);
+        return instance;
+    }
+    async _onError(error) {
         if (this.onError)
-            await this.onError(context, error);
+            await this.onError(error);
+    }
+    getConnection() {
+        if (!this.context)
+            throw new Error(`Context not set!`);
+        if (!this.db)
+            throw new Error(`Database not set!`);
+        return this.db;
     }
 }
 exports.SqbEntityService = SqbEntityService;