@opra/sqb 0.13.0 → 0.15.0

package/cjs/{base-entity-service.js → sqb-entity-service.js}

@@ -1,94 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntityService = void 0;
-const common_1 = require("@opra/common");
+exports.SqbEntityService = void 0;
 const connect_1 = require("@sqb/connect");
-class BaseEntityService {
+class SqbEntityService {
     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;
+        this._entityMetadata = metadata;
     }
-    async create(data, options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async create(context, data, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'create');
+            out = this.onTransformRow(context, out, 'create');
         return out;
     }
-    async count(options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async count(context, options) {
+        const conn = await this.getConnection(context);
         const repo = conn.getRepository(this.resourceType);
         try {
             return await repo.count(options);
         }
         catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
+            await this._onError(context, e);
+            throw e;
         }
     }
-    async delete(keyValue, options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async destroy(context, keyValue, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
     }
-    async deleteMany(options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async destroyAll(context, options) {
+        const conn = await this.getConnection(context);
         const repo = conn.getRepository(this.resourceType);
         try {
             return await repo.destroyAll(options);
         }
         catch (e) {
-            await this._onError(e);
-            throw new common_1.BadRequestError(e);
+            await this._onError(context, e);
+            throw e;
         }
     }
-    async get(keyValue, options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async findByPk(context, keyValue, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'get');
+            out = this.onTransformRow(context, out, 'read');
         return out;
     }
-    async search(options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async findOne(context, options) {
+        const conn = await this.getConnection(context);
+        const repo = conn.getRepository(this.resourceType);
+        let out;
+        try {
+            out = await repo.findOne(options);
+        }
+        catch (e) {
+            await this._onError(context, e);
+            throw e;
+        }
+        if (out && this.onTransformRow)
+            out = this.onTransformRow(context, out, 'read');
+        return out;
+    }
+    async findAll(context, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
         if (items.length && this.onTransformRow) {
             const newItems = [];
             for (const item of items) {
-                const v = this.onTransformRow(item, userContext, 'search');
+                const v = this.onTransformRow(context, item, 'read');
                 if (v)
                     newItems.push(v);
             }
@@ -96,35 +110,35 @@ class BaseEntityService {
         }
         return items;
     }
-    async update(keyValue, data, options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async update(context, keyValue, data, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
         if (out && this.onTransformRow)
-            out = this.onTransformRow(out, userContext, 'update');
+            out = this.onTransformRow(context, out, 'update');
         return out;
     }
-    async updateMany(data, options, userContext) {
-        const conn = await this.getConnection(userContext);
+    async updateAll(context, data, options) {
+        const conn = await this.getConnection(context);
         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);
+            await this._onError(context, e);
+            throw e;
         }
     }
-    async _onError(e) {
+    async _onError(context, error) {
         if (this.onError)
-            await this.onError(e);
+            await this.onError(context, error);
     }
 }
-exports.BaseEntityService = BaseEntityService;
+exports.SqbEntityService = SqbEntityService;

package/cjs/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.parseSingletonCreateRequest(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.parseSingletonDeleteRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return !!(await service.destroyAll(ctx, prepared.options));
+    }
+    async get(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.parseSingletonGetRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.findOne(ctx, prepared.options);
+    }
+    async update(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.parseSingletonUpdateRequest(ctx.request);
+        const service = await this.getService(ctx);
+        await service.updateAll(ctx, prepared.data, prepared.options);
+        return service.findOne(ctx, prepared.options);
+    }
+}
+tslib_1.__decorate([
+    common_1.Singleton.CreateOperation(),
+    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.DeleteOperation(),
+    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.GetOperation(),
+    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.UpdateOperation(),
+    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/augmentation/document-factory.augmentation.d.ts

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

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

@@ -0,0 +1,110 @@
+import { DocumentFactory, METADATA_KEY } from "@opra/common";
+import { DataType as SqbDataType, EntityMetadata, isAssociationField } from '@sqb/connect';
+// @ts-ignore
+const _extractFieldSchema = DocumentFactory.prototype.extractFieldSchema;
+// @ts-ignore
+DocumentFactory.prototype.extractFieldSchema = async function (target, ctor, metadata, name) {
+    await _extractFieldSchema.call(this, target, ctor, metadata, name);
+    const sqbMeta = EntityMetadata.get(ctor);
+    const sqbField = sqbMeta && EntityMetadata.getField(sqbMeta, name);
+    if (!sqbField)
+        return;
+    const detectType = !metadata.type;
+    if (isAssociationField(sqbField)) {
+        if (!sqbField.association.returnsMany())
+            delete target.isArray;
+        if (!target.type) {
+            const trg = await sqbField.association.resolveTarget();
+            if (trg) {
+                // @ts-ignore
+                target.type = await this.importTypeClass(trg.ctor);
+            }
+        }
+    }
+    else if (sqbField.kind === 'column') {
+        if (sqbField.type && Reflect.hasMetadata(METADATA_KEY, sqbField.type)) {
+            target.type = sqbField.type;
+        }
+        switch (sqbField.dataType) {
+            case SqbDataType.GUID:
+                if (!target.type || (detectType && target.type === 'string'))
+                    target.type = 'guid';
+                break;
+            case SqbDataType.JSON:
+                if (!target.type || (detectType && target.type === 'any'))
+                    target.type = 'object';
+                break;
+            case SqbDataType.INTEGER:
+            case SqbDataType.SMALLINT:
+                if (!target.type || (detectType && target.type === 'number'))
+                    target.type = 'integer';
+                break;
+            case SqbDataType.BIGINT:
+                if (!target.type || (detectType && target.type === 'number'))
+                    target.type = 'bigint';
+                break;
+            case SqbDataType.DATE:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'date';
+                break;
+            case SqbDataType.TIMESTAMPTZ:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'timestamptz';
+                break;
+            case SqbDataType.TIME:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'time';
+                break;
+            case SqbDataType.BINARY:
+                if (!target.type || (detectType && target.type === 'string'))
+                    target.type = 'base64';
+                break;
+        }
+        if (!target.type) {
+            switch (sqbField.dataType) {
+                case SqbDataType.BOOL:
+                    target.type = 'boolean';
+                    break;
+                case SqbDataType.CHAR:
+                case SqbDataType.VARCHAR:
+                case SqbDataType.TEXT:
+                    target.type = 'string';
+                    break;
+                case SqbDataType.FLOAT:
+                case SqbDataType.DOUBLE:
+                case SqbDataType.NUMBER:
+                    target.type = 'number';
+                    break;
+                case SqbDataType.TIMESTAMP:
+                    target.type = 'timestamp';
+                    break;
+            }
+        }
+        if (sqbField.notNull && target.required === undefined)
+            target.required = sqbField.notNull;
+        if (sqbField.exclusive && target.exclusive === undefined)
+            target.exclusive = sqbField.exclusive;
+        if (sqbField.default !== undefined && target.default === undefined)
+            target.default = sqbField.default;
+    }
+    if (sqbField.exclusive && target.exclusive === undefined)
+        target.exclusive = sqbField.exclusive;
+};
+// @ts-ignore
+const _createCollection = DocumentFactory.prototype.createCollection;
+// @ts-ignore
+DocumentFactory.prototype.createCollection = async function (name, schema) {
+    const { document } = this;
+    const dataType = document.getComplexType(schema.type);
+    // Determine primaryKey if not defined
+    if (!schema.primaryKey && dataType.ctor) {
+        const entityMetadata = EntityMetadata.get(dataType.ctor);
+        if (entityMetadata?.indexes) {
+            const primaryIndex = entityMetadata.indexes.find(x => x.primary);
+            if (primaryIndex) {
+                schema.primaryKey = primaryIndex.columns;
+            }
+        }
+    }
+    return await _createCollection.call(this, name, schema);
+};

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

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

package/esm/augmentation/mapped-type.augmentation.js

@@ -0,0 +1,12 @@
+import { MappedType } from "@opra/common";
+import { Entity, EntityMetadata } from '@sqb/connect';
+const _applyMixin = MappedType._applyMixin;
+MappedType._applyMixin = function (target, source, options) {
+    _applyMixin.call(null, target, source, options);
+    const srcMeta = Entity.getMetadata(source);
+    if (srcMeta) {
+        const trgMeta = EntityMetadata.define(target);
+        const { isInheritedPredicate } = options;
+        EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
+    }
+};

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

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

package/esm/augmentation/union-type.augmentation.js

@@ -0,0 +1,7 @@
+import { UnionType } from "@opra/common";
+import { Entity } from '@sqb/connect';
+const _applyMixin = UnionType._applyMixin;
+UnionType._applyMixin = function (target, ...sources) {
+    _applyMixin.call(null, target, ...sources);
+    Entity.mixin(target, ...sources);
+};

package/esm/convert-filter.js

@@ -6,7 +6,8 @@ export function convertFilter(str) {
         return;
     if (ast instanceof ComparisonExpression) {
         const left = ast.left instanceof QualifiedIdentifier
-            ? ast.left.value : convertFilter(ast.left);
+            ? sqb.Field(ast.left.value)
+            : convertFilter(ast.left);
         const right = convertFilter(ast.right);
         switch (ast.op) {
             case '=':
@@ -38,7 +39,7 @@ export function convertFilter(str) {
         }
     }
     if (ast instanceof QualifiedIdentifier) {
-        return sqb.Field(ast.value);
+        return ast.value;
     }
     if (ast instanceof NumberLiteral ||
         ast instanceof StringLiteral ||

package/esm/index.d.ts

@@ -1,8 +1,7 @@
-import * as _SqbConnect from '@sqb/connect';
+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 './base-entity-resource.js';
-export * from './base-entity-service.js';
-export type { _SqbConnect as SqbConnect };
-declare global {
-    export type SqbConnect = typeof _SqbConnect;
-}
+export * from './sqb-collection-resource.js';
+export * from './sqb-entity-service.js';
+export * from './sqb-singleton-resource.js';

package/esm/index.js

@@ -1,7 +1,7 @@
-import * as _SqbConnect from '@sqb/connect';
+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 './base-entity-resource.js';
-export * from './base-entity-service.js';
-const optionalsSymbol = Symbol.for('opra.optional-lib.sqb-connect');
-globalThis[optionalsSymbol] = globalThis[optionalsSymbol] || {};
-globalThis[optionalsSymbol].SqbConnect = _SqbConnect;
+export * from './sqb-collection-resource.js';
+export * from './sqb-entity-service.js';
+export * from './sqb-singleton-resource.js';

package/esm/sqb-adapter.d.ts

@@ -1,10 +1,64 @@
-import { OpraQuery } from '@opra/common';
+import { Request } from '@opra/core';
+import { convertFilter } from './convert-filter.js';
 export declare namespace SQBAdapter {
-    function prepare(query: OpraQuery): {
-        method: 'create' | 'count' | 'findByPk' | 'findAll' | 'update' | 'updateAll' | 'destroy' | 'destroyAll';
+    const parseFilter: typeof convertFilter;
+    type parseFilter = typeof convertFilter;
+    function parseCollectionCreateRequest(request: Request): {
+        method: string;
+        data: any;
+        options: any;
+    };
+    function parseCollectionDeleteRequest(request: Request): {
+        method: string;
+        key: any;
+        options: {};
+    };
+    function parseCollectionDeleteManyRequest(request: Request): {
+        method: string;
+        options: any;
+    };
+    function parseCollectionGetRequest(request: Request): {
+        method: string;
+        key: any;
+        options: any;
+    };
+    function parseCollectionUpdateRequest(request: Request): {
+        method: string;
+        key: any;
+        data: any;
+        options: any;
+    };
+    function parseCollectionUpdateManyRequest(request: Request): {
+        method: string;
+        data: any;
+        options: any;
+    };
+    function parseCollectionSearchRequest(request: Request): {
+        method: string;
+        options: any;
+    };
+    function parseSingletonGetRequest(request: Request): {
+        method: string;
+        options: any;
+    };
+    function parseSingletonCreateRequest(request: Request): {
+        method: string;
+        data: any;
+        options: any;
+    };
+    function parseSingletonDeleteRequest(request: Request): {
+        method: string;
+        options: {};
+    };
+    function parseSingletonUpdateRequest(request: Request): {
+        method: string;
+        data: any;
+        options: any;
+    };
+    function parseRequest(request: Request): {
+        method: string;
+        key?: any;
+        data?: any;
         options: any;
-        keyValue?: any;
-        values?: any;
-        args: any[];
     };
 }