@opra/sqb 0.15.0 → 0.16.0

package/esm/sqb-collection-resource.js

@@ -1,39 +1,42 @@
-import { __decorate, __metadata } from "tslib";
-import { Collection } from '@opra/common';
-import { SQBAdapter } from './sqb-adapter.js';
-export class SqbCollectionResource {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbCollectionResource = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const sqb_adapter_js_1 = require("./sqb-adapter.js");
+class SqbCollectionResource {
     async create(ctx) {
-        const prepared = 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 = 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 = 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 = 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 = 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 = 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 = 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([
@@ -47,45 +50,46 @@ export class SqbCollectionResource {
             return service.findAll(ctx, prepared.options);
     }
 }
-__decorate([
-    Collection.CreateOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbCollectionResource.prototype, "create", null);
-__decorate([
-    Collection.DeleteOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbCollectionResource.prototype, "delete", null);
-__decorate([
-    Collection.DeleteManyOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbCollectionResource.prototype, "deleteMany", null);
-__decorate([
-    Collection.GetOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], SqbCollectionResource.prototype, "get", null);
-__decorate([
-    Collection.UpdateOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
+], SqbCollectionResource.prototype, "find", 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)
 ], SqbCollectionResource.prototype, "update", null);
-__decorate([
-    Collection.UpdateManyOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbCollectionResource.prototype, "updateMany", null);
-__decorate([
-    Collection.SearchOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbCollectionResource.prototype, "search", null);
+exports.SqbCollectionResource = SqbCollectionResource;

package/esm/sqb-entity-service.js

@@ -1,105 +1,111 @@
-import { EntityMetadata } from '@sqb/connect';
-export class SqbEntityService {
-    constructor(resourceType) {
-        this.resourceType = resourceType;
-        const metadata = EntityMetadata.get(resourceType);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbEntityService = void 0;
+const connect_1 = require("@sqb/connect");
+class SqbEntityService {
+    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);
             }
@@ -107,34 +113,64 @@ export 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;

package/esm/sqb-singleton-resource.js

@@ -1,50 +1,54 @@
-import { __decorate, __metadata } from "tslib";
-import { Singleton } from '@opra/common';
-import { SQBAdapter } from './sqb-adapter.js';
-export class SqbSingletonResource {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbSingletonResource = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const sqb_adapter_js_1 = require("./sqb-adapter.js");
+class SqbSingletonResource {
     async create(ctx) {
-        const prepared = SQBAdapter.parseSingletonCreateRequest(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 = SQBAdapter.parseSingletonDeleteRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        return !!(await service.destroyAll(ctx, prepared.options));
+        return !!(await service.deleteMany(ctx, prepared.options));
     }
     async get(ctx) {
-        const prepared = SQBAdapter.parseSingletonGetRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
         return service.findOne(ctx, prepared.options);
     }
     async update(ctx) {
-        const prepared = SQBAdapter.parseSingletonUpdateRequest(ctx.request);
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
         const service = await this.getService(ctx);
-        await service.updateAll(ctx, prepared.data, prepared.options);
+        await service.updateMany(ctx, prepared.data, prepared.options);
         return service.findOne(ctx, prepared.options);
     }
 }
-__decorate([
-    Singleton.CreateOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbSingletonResource.prototype, "create", null);
-__decorate([
-    Singleton.DeleteOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbSingletonResource.prototype, "delete", null);
-__decorate([
-    Singleton.GetOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbSingletonResource.prototype, "get", null);
-__decorate([
-    Singleton.UpdateOperation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
+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)
 ], SqbSingletonResource.prototype, "update", null);
+exports.SqbSingletonResource = SqbSingletonResource;

package/esm/transform-filter.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const sqb = tslib_1.__importStar(require("@sqb/builder"));
+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
+            ? sqb.Field(ast.left.value)
+            : transformFilter(ast.left);
+        const right = transformFilter(ast.right);
+        switch (ast.op) {
+            case '=':
+                return sqb.Eq(left, right);
+            case '!=':
+                return sqb.Ne(left, right);
+            case '>':
+                return sqb.Gt(left, right);
+            case '>=':
+                return sqb.Gte(left, right);
+            case '<':
+                return sqb.Lt(left, right);
+            case '<=':
+                return sqb.Lte(left, right);
+            case 'in':
+                return sqb.In(left, right);
+            case '!in':
+                return sqb.Nin(left, right);
+            case 'like':
+                return sqb.Like(left, right);
+            case 'ilike':
+                return sqb.Ilike(left, right);
+            case '!like':
+                return sqb.NotLike(left, right);
+            case '!ilike':
+                return sqb.NotILike(left, right);
+            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 sqb.Or(...ast.items.map(transformFilter));
+        return sqb.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -30,18 +30,18 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^7.6.0",
-    "@sqb/builder": "^4.6.3",
-    "@sqb/connect": "^4.6.3",
-    "@sqb/postgres": "^4.6.3",
+    "@sqb/builder": "^4.8.2",
+    "@sqb/connect": "^4.8.2",
+    "@sqb/postgres": "^4.8.2",
     "postgresql-client": "^2.5.5",
     "ts-gems": "^2.3.0"
   },
   "peerDependencies": {
-    "@opra/core": "^0.15.0",
-    "@sqb/connect": ">= 4.5.4"
+    "@opra/core": "^0.16.0",
+    "@sqb/connect": ">= 4.8.2"
   },
   "type": "module",
-  "types": "esm/index.d.ts",
+  "types": "types/index.d.ts",
   "exports": {
     ".": {
       "require": "./cjs/index.js",
@@ -58,6 +58,7 @@
     "bin/",
     "cjs/",
     "esm/",
+    "types/",
     "LICENSE",
     "README.md"
   ],

package/types/sqb-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Request } from '@opra/core';
+import _transformFilter from './transform-filter.js';
+import _transformKeyValues from './transform-key-values.js';
+export declare namespace SQBAdapter {
+    const transformFilter: typeof _transformFilter;
+    const transformKeyValues: typeof _transformKeyValues;
+    function transformRequest(request: Request): {
+        method: 'create' | 'delete' | 'deleteMany' | 'find' | 'findOne' | 'findMany' | 'update' | 'updateMany';
+        key?: any;
+        data?: any;
+        options: any;
+        args: any[];
+    };
+}

package/{esm → types}/sqb-collection-resource.d.ts

@@ -6,7 +6,7 @@ export declare abstract class SqbCollectionResource<T> {
     create(ctx: RequestContext): Promise<PartialOutput<T>>;
     delete(ctx: RequestContext): Promise<boolean>;
     deleteMany(ctx: RequestContext): Promise<number>;
-    get(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
+    find(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
     update(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
     updateMany(ctx: RequestContext): Promise<number>;
     search(ctx: RequestContext): Promise<PartialOutput<T>[]>;

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

@@ -0,0 +1,31 @@
+import { Maybe, Type } from 'ts-gems';
+import { PartialInput, PartialOutput, RequestContext } from '@opra/core';
+import { EntityInput, Repository, SqbClient, SqbConnection } from '@sqb/connect';
+export declare namespace SqbEntityService {
+    interface Options {
+        db?: SqbClient | SqbConnection;
+        defaultLimit?: number;
+    }
+}
+export declare class SqbEntityService<T, TOutput = PartialOutput<T>> {
+    readonly typeClass: Type<T>;
+    context: RequestContext;
+    defaultLimit: number;
+    db?: SqbClient | SqbConnection;
+    constructor(typeClass: Type<T>, options?: SqbEntityService.Options);
+    count(context: RequestContext, options?: Repository.CountOptions): Promise<number>;
+    create(context: RequestContext, data: PartialInput<T>, options?: Repository.CreateOptions): Promise<TOutput>;
+    delete(context: RequestContext, keyValue: any, options?: Repository.DestroyOptions): Promise<boolean>;
+    deleteMany(context: RequestContext, options?: Repository.DestroyOptions): Promise<number>;
+    find(context: RequestContext, keyValue: any, options?: Repository.FindOptions): Promise<Maybe<TOutput>>;
+    findOne(context: RequestContext, options?: Repository.FindOneOptions): Promise<Maybe<TOutput>>;
+    findAll(context: RequestContext, options?: Repository.FindAllOptions): Promise<TOutput[]>;
+    exists(context: RequestContext, options?: Repository.ExistsOptions): Promise<boolean>;
+    update(context: RequestContext, keyValue: any, data: EntityInput<T>, options?: Repository.UpdateOptions): Promise<Maybe<TOutput>>;
+    updateMany(context: RequestContext, data: PartialInput<T>, options?: Repository.UpdateAllOptions): Promise<number>;
+    with(context: RequestContext, db?: SqbClient | SqbConnection): SqbEntityService<T, TOutput>;
+    protected _onError(error: unknown): Promise<void>;
+    protected getConnection(): SqbConnection | SqbClient | Promise<SqbConnection | SqbClient>;
+    protected onError?(error: unknown): void | Promise<void>;
+    protected onTransformRow?(row: TOutput): TOutput;
+}

package/types/transform-filter.d.ts

@@ -0,0 +1,2 @@
+import { Expression } from '@opra/common';
+export default function transformFilter(str: string | Expression | undefined): any;

package/types/transform-key-values.d.ts

@@ -0,0 +1,3 @@
+import mongodb from 'mongodb';
+import { Collection } from '@opra/common';
+export default function transformKeyValues(resource: Collection, keyValues: any): mongodb.Filter<any>;

package/esm/convert-filter.d.ts

@@ -1,2 +0,0 @@
-import { Expression } from '@opra/common';
-export declare function convertFilter(str: string | Expression | undefined): any;