@opra/sqb 0.26.1 → 0.26.4

package/cjs/sqb-collection.js

@@ -10,37 +10,37 @@ class SqbCollection {
         this.defaultLimit = options?.defaultLimit || 100;
     }
     async create(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).create(prepared.data, prepared.options);
+        return service.create(prepared.data, prepared.options);
     }
     async delete(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).delete(prepared.key, prepared.options);
+        return service.delete(prepared.key, prepared.options);
     }
     async deleteMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).deleteMany(prepared.options);
+        return service.deleteMany(prepared.options);
     }
     async get(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).find(prepared.key, prepared.options);
+        return service.find(prepared.key, prepared.options);
     }
     async update(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).update(prepared.key, prepared.data, prepared.options);
+        return service.update(prepared.key, prepared.data, prepared.options);
     }
     async updateMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).updateMany(prepared.data, prepared.options);
+        return service.updateMany(prepared.data, prepared.options);
     }
     async findMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
         if (prepared.options.count) {
             const [items, count] = await Promise.all([
@@ -51,7 +51,11 @@ class SqbCollection {
             return items;
         }
         else
-            return service.with(ctx).findMany(prepared.options);
+            return service.findMany(prepared.options);
+    }
+    async _prepare(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
     }
 }
 exports.SqbCollection = SqbCollection;

package/cjs/sqb-entity-service.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqbEntityService = void 0;
+const core_1 = require("@opra/core");
 const connect_1 = require("@sqb/connect");
-class SqbEntityService {
+class SqbEntityService extends core_1.ApiService {
     constructor(typeClass, options) {
+        super();
         this.typeClass = typeClass;
         const metadata = connect_1.EntityMetadata.get(typeClass);
         if (!metadata)
@@ -43,7 +45,7 @@ class SqbEntityService {
         const conn = await this.getConnection();
         const repo = conn.getRepository(this.typeClass);
         try {
-            return await repo.delete(keyValue, options);
+            return await repo.delete(keyValue, options) ? 1 : 0;
         }
         catch (e) {
             await this._onError(e);
@@ -151,14 +153,11 @@ class SqbEntityService {
         }
     }
     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 this.forContext(context, db);
+    }
+    forContext(context, db) {
+        const instance = super.forContext(context);
+        instance.db = db || this.db;
         return instance;
     }
     async _onError(error) {

package/cjs/sqb-singleton.js

@@ -6,25 +6,29 @@ const common_1 = require("@opra/common");
 const sqb_adapter_js_1 = require("./sqb-adapter.js");
 class SqbSingleton {
     async create(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).create(prepared.data, prepared.options);
+        return service.create(prepared.data, prepared.options);
     }
     async delete(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return !!(await service.with(ctx).deleteMany(prepared.options));
+        return await service.deleteMany(prepared.options);
     }
     async get(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).findOne(prepared.options);
+        return service.findOne(prepared.options);
     }
     async update(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        await service.with(ctx).updateMany(prepared.data, prepared.options);
-        return service.with(ctx).findOne(prepared.options);
+        await service.updateMany(prepared.data, prepared.options);
+        return service.findOne(prepared.options);
+    }
+    async _prepare(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
     }
 }
 exports.SqbSingleton = SqbSingleton;

package/esm/sqb-collection.js

@@ -7,37 +7,37 @@ export class SqbCollection {
         this.defaultLimit = options?.defaultLimit || 100;
     }
     async create(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).create(prepared.data, prepared.options);
+        return service.create(prepared.data, prepared.options);
     }
     async delete(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).delete(prepared.key, prepared.options);
+        return service.delete(prepared.key, prepared.options);
     }
     async deleteMany(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).deleteMany(prepared.options);
+        return service.deleteMany(prepared.options);
     }
     async get(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).find(prepared.key, prepared.options);
+        return service.find(prepared.key, prepared.options);
     }
     async update(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).update(prepared.key, prepared.data, prepared.options);
+        return service.update(prepared.key, prepared.data, prepared.options);
     }
     async updateMany(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).updateMany(prepared.data, prepared.options);
+        return service.updateMany(prepared.data, prepared.options);
     }
     async findMany(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
         if (prepared.options.count) {
             const [items, count] = await Promise.all([
@@ -48,7 +48,11 @@ export class SqbCollection {
             return items;
         }
         else
-            return service.with(ctx).findMany(prepared.options);
+            return service.findMany(prepared.options);
+    }
+    async _prepare(ctx) {
+        const prepared = SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
     }
 }
 __decorate([

package/esm/sqb-entity-service.js

@@ -1,6 +1,8 @@
+import { ApiService } from '@opra/core';
 import { EntityMetadata } from '@sqb/connect';
-export class SqbEntityService {
+export class SqbEntityService extends ApiService {
     constructor(typeClass, options) {
+        super();
         this.typeClass = typeClass;
         const metadata = EntityMetadata.get(typeClass);
         if (!metadata)
@@ -40,7 +42,7 @@ export class SqbEntityService {
         const conn = await this.getConnection();
         const repo = conn.getRepository(this.typeClass);
         try {
-            return await repo.delete(keyValue, options);
+            return await repo.delete(keyValue, options) ? 1 : 0;
         }
         catch (e) {
             await this._onError(e);
@@ -148,14 +150,11 @@ export class SqbEntityService {
         }
     }
     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 this.forContext(context, db);
+    }
+    forContext(context, db) {
+        const instance = super.forContext(context);
+        instance.db = db || this.db;
         return instance;
     }
     async _onError(error) {

package/esm/sqb-singleton.js

@@ -3,25 +3,29 @@ import { Singleton } from '@opra/common';
 import { SQBAdapter } from './sqb-adapter.js';
 export class SqbSingleton {
     async create(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).create(prepared.data, prepared.options);
+        return service.create(prepared.data, prepared.options);
     }
     async delete(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return !!(await service.with(ctx).deleteMany(prepared.options));
+        return await service.deleteMany(prepared.options);
     }
     async get(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        return service.with(ctx).findOne(prepared.options);
+        return service.findOne(prepared.options);
     }
     async update(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
+        const prepared = await this._prepare(ctx);
         const service = await this.getService(ctx);
-        await service.with(ctx).updateMany(prepared.data, prepared.options);
-        return service.with(ctx).findOne(prepared.options);
+        await service.updateMany(prepared.data, prepared.options);
+        return service.findOne(prepared.options);
+    }
+    async _prepare(ctx) {
+        const prepared = SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
     }
 }
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "0.26.1",
+  "version": "0.26.4",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "ts-gems": "^2.5.0"
   },
   "peerDependencies": {
-    "@opra/core": "^0.26.1",
+    "@opra/core": "^0.26.4",
     "@sqb/connect": ">= 4.9.0"
   },
   "type": "module",

package/types/sqb-adapter.d.ts

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

package/types/sqb-collection.d.ts

@@ -1,21 +1,24 @@
 import { Maybe } from 'ts-gems';
-import { PartialOutput } from '@opra/common';
+import { ICollection, PartialOutput } from '@opra/common';
 import { RequestContext } from '@opra/core';
+import { SQBAdapter } from './sqb-adapter.js';
 import { SqbEntityService } from './sqb-entity-service.js';
 export declare namespace SqbCollection {
     interface Options {
         defaultLimit?: number;
     }
 }
-export declare abstract class SqbCollection<T, TOutput = PartialOutput<T>> {
+export declare abstract class SqbCollection<T> implements ICollection<T> {
     defaultLimit?: number;
     constructor(options?: SqbCollection.Options);
-    create(ctx: RequestContext): Promise<TOutput>;
-    delete(ctx: RequestContext): Promise<boolean>;
-    deleteMany(ctx: RequestContext): Promise<number>;
-    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): SqbEntityService<T, TOutput> | Promise<SqbEntityService<T, TOutput>>;
+    create?(ctx: RequestContext): Promise<PartialOutput<T>>;
+    delete?(ctx: RequestContext): Promise<number>;
+    deleteMany?(ctx: RequestContext): Promise<number>;
+    get?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
+    update?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
+    updateMany?(ctx: RequestContext): Promise<number>;
+    findMany?(ctx: RequestContext): Promise<PartialOutput<T>[]>;
+    protected _prepare(ctx: RequestContext): Promise<SQBAdapter.TransformedRequest>;
+    onPrepare?(ctx: RequestContext, prepared: SQBAdapter.TransformedRequest): SQBAdapter.TransformedRequest | Promise<SQBAdapter.TransformedRequest>;
+    protected abstract getService(ctx: RequestContext): SqbEntityService<T> | Promise<SqbEntityService<T>>;
 }

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

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

package/types/sqb-singleton.d.ts

@@ -1,11 +1,14 @@
 import { Maybe } from 'ts-gems';
-import { PartialOutput } from '@opra/common';
+import { ISingleton, PartialOutput } from '@opra/common';
 import { RequestContext } from '@opra/core';
+import { SQBAdapter } from './sqb-adapter.js';
 import { SqbEntityService } from './sqb-entity-service.js';
-export declare abstract class SqbSingleton<T> {
-    create(ctx: RequestContext): Promise<PartialOutput<T>>;
-    delete(ctx: RequestContext): Promise<boolean>;
-    get(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    update(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    abstract getService(req: RequestContext): SqbEntityService<T> | Promise<SqbEntityService<T>>;
+export declare abstract class SqbSingleton<T> implements ISingleton<T> {
+    create?(ctx: RequestContext): Promise<PartialOutput<T>>;
+    delete?(ctx: RequestContext): Promise<number>;
+    get?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
+    update?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
+    protected _prepare(ctx: RequestContext): Promise<SQBAdapter.TransformedRequest>;
+    onPrepare?(ctx: RequestContext, prepared: SQBAdapter.TransformedRequest): SQBAdapter.TransformedRequest | Promise<SQBAdapter.TransformedRequest>;
+    protected abstract getService(ctx: RequestContext): SqbEntityService<T> | Promise<SqbEntityService<T>>;
 }