@opra/sqb 0.26.0 → 0.26.3

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);
     }
     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);
     }
     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);
     }
     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);
     }
     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);
     }
     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);
     }
     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([
@@ -53,6 +53,10 @@ class SqbCollection {
         else
             return service.with(ctx).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;
 tslib_1.__decorate([

package/cjs/sqb-entity-service.js

@@ -43,7 +43,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,6 +151,9 @@ class SqbEntityService {
         }
     }
     with(context, db) {
+        return this.forContext(context, db);
+    }
+    forContext(context, db) {
         if (this.context === context && this.db === db)
             return this;
         const instance = { context };

package/cjs/sqb-singleton.js

@@ -6,26 +6,30 @@ 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);
     }
     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.with(ctx).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);
     }
     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);
     }
+    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;
 tslib_1.__decorate([

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);
     }
     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);
     }
     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);
     }
     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);
     }
     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);
     }
     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);
     }
     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([
@@ -50,6 +50,10 @@ export class SqbCollection {
         else
             return service.with(ctx).findMany(prepared.options);
     }
+    async _prepare(ctx) {
+        const prepared = SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
+    }
 }
 __decorate([
     Collection.Create()

package/esm/sqb-entity-service.js

@@ -40,7 +40,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,6 +148,9 @@ export class SqbEntityService {
         }
     }
     with(context, db) {
+        return this.forContext(context, db);
+    }
+    forContext(context, db) {
         if (this.context === context && this.db === db)
             return this;
         const instance = { context };

package/esm/sqb-singleton.js

@@ -3,26 +3,30 @@ 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);
     }
     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.with(ctx).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);
     }
     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);
     }
+    async _prepare(ctx) {
+        const prepared = SQBAdapter.transformRequest(ctx.request);
+        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
+    }
 }
 __decorate([
     Singleton.Create()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "0.26.0",
+  "version": "0.26.3",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -29,15 +29,15 @@
     "lodash.omitby": "^4.6.0"
   },
   "devDependencies": {
-    "@faker-js/faker": "^8.0.2",
+    "@faker-js/faker": "^8.1.0",
     "@sqb/builder": "^4.9.1",
     "@sqb/connect": "^4.9.1",
     "@sqb/postgres": "^4.9.1",
-    "postgresql-client": "^2.7.1",
+    "postgresql-client": "^2.9.1",
     "ts-gems": "^2.5.0"
   },
   "peerDependencies": {
-    "@opra/core": "^0.26.0",
+    "@opra/core": "^0.26.3",
     "@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

@@ -7,25 +7,26 @@ export declare namespace SqbEntityService {
         defaultLimit?: number;
     }
 }
-export declare class SqbEntityService<T, TOutput = PartialOutput<T>> {
+export declare class SqbEntityService<T> {
     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): SqbEntityService<T>;
     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>>;
 }