@opra/sqb 0.14.0 → 0.16.0

package/esm/sqb-entity-service.js

@@ -0,0 +1,176 @@
+"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(`Class ${typeClass} is not decorated with $Entity() decorator`);
+        this.db = options?.db;
+        this.defaultLimit = options?.defaultLimit || 10;
+    }
+    async count(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        try {
+            return await repo.count(options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async create(context, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        let out;
+        try {
+            out = await repo.create(data, options);
+        }
+        catch (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 delete(context, keyValue, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        try {
+            return await repo.delete(keyValue, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async deleteMany(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        try {
+            return await repo.deleteMany(options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    async find(context, keyValue, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        let out;
+        try {
+            out = await repo.find(keyValue, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (out && this.onTransformRow)
+            out = this.onTransformRow(out);
+        return out;
+    }
+    async findOne(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        let out;
+        try {
+            out = await repo.findOne(options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (out && this.onTransformRow)
+            out = this.onTransformRow(out);
+        return out;
+    }
+    async findAll(context, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        let items;
+        try {
+            items = await repo.findAll(options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (items.length && this.onTransformRow) {
+            const newItems = [];
+            for (const item of items) {
+                const v = this.onTransformRow(item);
+                if (v)
+                    newItems.push(v);
+            }
+            return newItems;
+        }
+        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();
+        const repo = conn.getRepository(this.typeClass);
+        let out;
+        try {
+            out = await repo.update(keyValue, data, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+        if (out && this.onTransformRow)
+            out = this.onTransformRow(out);
+        return out;
+    }
+    async updateMany(context, data, options) {
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.typeClass);
+        try {
+            return await repo.updateMany(data, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    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(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

@@ -0,0 +1,54 @@
+"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 = 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.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return !!(await service.deleteMany(ctx, prepared.options));
+    }
+    async get(ctx) {
+        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 = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        await service.updateMany(ctx, prepared.data, prepared.options);
+        return service.findOne(ctx, prepared.options);
+    }
+}
+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);
+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);
+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);
+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.14.0",
+  "version": "0.16.0",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -17,8 +17,8 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/sqb && cp ../../package.cjs.json ../../build/sqb/cjs/package.json",
     "lint": "eslint .",
-    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
-    "cover": "NODE_OPTIONS=--experimental-vm-modules npx jest --collect-coverage",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
     "clean:dist": "rimraf ../../build/sqb",
@@ -26,22 +26,22 @@
   },
   "dependencies": {
     "lodash.isnil": "^4.0.0",
-    "lodash.omitby": "^4.6.0",
-    "ts-gems": "^2.3.0"
+    "lodash.omitby": "^4.6.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^7.6.0",
-    "@sqb/builder": "^4.5.5",
-    "@sqb/connect": "^4.5.5",
-    "@sqb/postgres": "^4.5.5",
-    "postgresql-client": "^2.5.2"
+    "@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.14.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/augmentation/document-factory.augmentation.d.ts

@@ -0,0 +1 @@
+export {};

package/types/augmentation/mapped-type.augmentation.d.ts

@@ -0,0 +1 @@
+export {};

package/types/augmentation/union-type.augmentation.d.ts

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -0,0 +1,7 @@
+import './augmentation/document-factory.augmentation.js';
+import './augmentation/mapped-type.augmentation.js';
+import './augmentation/union-type.augmentation.js';
+export * from './sqb-adapter.js';
+export * from './sqb-collection-resource.js';
+export * from './sqb-entity-service.js';
+export * from './sqb-singleton-resource.js';

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/types/sqb-collection-resource.d.ts

@@ -0,0 +1,14 @@
+import { Maybe } from 'ts-gems';
+import { PartialOutput } from '@opra/common';
+import { RequestContext } from '@opra/core';
+import { SqbEntityService } from './sqb-entity-service.js';
+export declare abstract class SqbCollectionResource<T> {
+    create(ctx: RequestContext): Promise<PartialOutput<T>>;
+    delete(ctx: RequestContext): Promise<boolean>;
+    deleteMany(ctx: RequestContext): Promise<number>;
+    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>[]>;
+    abstract getService(ctx: RequestContext): SqbEntityService<T> | Promise<SqbEntityService<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/sqb-singleton-resource.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from 'ts-gems';
+import { PartialOutput } from '@opra/common';
+import { RequestContext } from '@opra/core';
+import { SqbEntityService } from './sqb-entity-service.js';
+export declare abstract class SqbSingletonResource<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>>;
+}

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/cjs/base-entity-resource.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntityResource = void 0;
-const sqb_adapter_js_1 = require("./sqb-adapter.js");
-class BaseEntityResource {
-    async create(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).create(prepared.values, prepared.options, ctx.userContext);
-    }
-    async count(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).count(prepared.options, ctx.userContext);
-    }
-    async delete(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).delete(prepared.keyValue, prepared.options, ctx.userContext);
-    }
-    async deleteMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).deleteMany(prepared.options, ctx.userContext);
-    }
-    async get(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).get(prepared.keyValue, prepared.options, ctx.userContext);
-    }
-    async search(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).search(prepared.options, ctx.userContext);
-    }
-    async update(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).update(prepared.keyValue, prepared.values, prepared.options, ctx.userContext);
-    }
-    async updateMany(ctx) {
-        const prepared = sqb_adapter_js_1.SQBAdapter.prepare(ctx.query);
-        return (await this.getService(ctx)).updateMany(prepared.values, prepared.options, ctx.userContext);
-    }
-}
-exports.BaseEntityResource = BaseEntityResource;

package/cjs/base-entity-service.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntityService = void 0;
-const common_1 = require("@opra/common");
-const connect_1 = require("@sqb/connect");
-class BaseEntityService {
-    constructor(resourceType) {
-        this.resourceType = resourceType;
-        const metadata = connect_1.EntityMetadata.get(resourceType);
-        if (!metadata)
-            throw new TypeError(`You must provide an SQB entity class`);
-        this._metadata = metadata;
-    }
-    async create(data, options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        let out;
-        try {
-            out = await repo.create(data, options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-        if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'create');
-        return out;
-    }
-    async count(options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        try {
-            return await repo.count(options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-    }
-    async delete(keyValue, options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        try {
-            return await repo.destroy(keyValue, options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-    }
-    async deleteMany(options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        try {
-            return await repo.destroyAll(options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-    }
-    async get(keyValue, options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        let out;
-        try {
-            out = await repo.findByPk(keyValue, options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-        if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'get');
-        return out;
-    }
-    async search(options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        let items;
-        try {
-            items = await repo.findAll(options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-        if (items.length && this.onTransformRow) {
-            const newItems = [];
-            for (const item of items) {
-                const v = this.onTransformRow(item, userContext, 'search');
-                if (v)
-                    newItems.push(v);
-            }
-            return newItems;
-        }
-        return items;
-    }
-    async update(keyValue, data, options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        let out;
-        try {
-            out = await repo.update(keyValue, data, options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-        if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'update');
-        return out;
-    }
-    async updateMany(data, options, userContext) {
-        const conn = await this.getConnection(userContext);
-        const repo = conn.getRepository(this.resourceType);
-        try {
-            return await repo.updateAll(data, options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
-        }
-    }
-    async _onError(e) {
-        if (this.onError)
-            await this.onError(e);
-    }
-}
-exports.BaseEntityService = BaseEntityService;