@opra/sqb 0.14.0 → 0.16.0

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+// @ts-ignore
+const _extractFieldSchema = common_1.DocumentFactory.prototype.extractFieldSchema;
+// @ts-ignore
+common_1.DocumentFactory.prototype.extractFieldSchema = async function (target, ctor, metadata, name) {
+    await _extractFieldSchema.call(this, target, ctor, metadata, name);
+    const sqbMeta = connect_1.EntityMetadata.get(ctor);
+    const sqbField = sqbMeta && connect_1.EntityMetadata.getField(sqbMeta, name);
+    if (!sqbField)
+        return;
+    const detectType = !metadata.type;
+    if ((0, connect_1.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 (typeof sqbField.enum === 'object')
+            metadata.enum = sqbField.enum;
+        if (sqbField.type && Reflect.hasMetadata(common_1.METADATA_KEY, sqbField.type)) {
+            target.type = sqbField.type;
+        }
+        switch (sqbField.dataType) {
+            case connect_1.DataType.GUID:
+                if (!target.type || (detectType && target.type === 'string'))
+                    target.type = 'guid';
+                break;
+            case connect_1.DataType.JSON:
+                if (!target.type || (detectType && target.type === 'any'))
+                    target.type = 'object';
+                break;
+            case connect_1.DataType.INTEGER:
+            case connect_1.DataType.SMALLINT:
+                if (!target.type || (detectType && target.type === 'number'))
+                    target.type = 'integer';
+                break;
+            case connect_1.DataType.BIGINT:
+                if (!target.type || (detectType && target.type === 'number'))
+                    target.type = 'bigint';
+                break;
+            case connect_1.DataType.DATE:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'date';
+                break;
+            case connect_1.DataType.TIMESTAMPTZ:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'timestamptz';
+                break;
+            case connect_1.DataType.TIME:
+                if (!target.type || (detectType && (target.type === 'timestamp' || target.type === 'string')))
+                    target.type = 'time';
+                break;
+            case connect_1.DataType.BINARY:
+                if (!target.type || (detectType && target.type === 'string'))
+                    target.type = 'base64';
+                break;
+        }
+        if (!target.type) {
+            switch (sqbField.dataType) {
+                case connect_1.DataType.BOOL:
+                    target.type = 'boolean';
+                    break;
+                case connect_1.DataType.CHAR:
+                case connect_1.DataType.VARCHAR:
+                case connect_1.DataType.TEXT:
+                    target.type = 'string';
+                    break;
+                case connect_1.DataType.FLOAT:
+                case connect_1.DataType.DOUBLE:
+                case connect_1.DataType.NUMBER:
+                    target.type = 'number';
+                    break;
+                case connect_1.DataType.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 = common_1.DocumentFactory.prototype.createCollection;
+// @ts-ignore
+common_1.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 = connect_1.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/cjs/augmentation/mapped-type.augmentation.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+const _applyMixin = common_1.MappedType._applyMixin;
+common_1.MappedType._applyMixin = function (target, source, options) {
+    _applyMixin.call(null, target, source, options);
+    const srcMeta = connect_1.Entity.getMetadata(source);
+    if (srcMeta) {
+        const trgMeta = connect_1.EntityMetadata.define(target);
+        const { isInheritedPredicate } = options;
+        connect_1.EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
+    }
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+const _applyMixin = common_1.UnionType._applyMixin;
+common_1.UnionType._applyMixin = function (target, ...sources) {
+    _applyMixin.call(null, target, ...sources);
+    connect_1.Entity.mixin(target, ...sources);
+};

package/cjs/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const _SqbConnect = tslib_1.__importStar(require("@sqb/connect"));
+require("./augmentation/document-factory.augmentation.js");
+require("./augmentation/mapped-type.augmentation.js");
+require("./augmentation/union-type.augmentation.js");
 tslib_1.__exportStar(require("./sqb-adapter.js"), exports);
-tslib_1.__exportStar(require("./base-entity-resource.js"), exports);
-tslib_1.__exportStar(require("./base-entity-service.js"), exports);
-const optionalsSymbol = Symbol.for('opra.optional-lib.sqb-connect');
-globalThis[optionalsSymbol] = globalThis[optionalsSymbol] || {};
-globalThis[optionalsSymbol].SqbConnect = _SqbConnect;
+tslib_1.__exportStar(require("./sqb-collection-resource.js"), exports);
+tslib_1.__exportStar(require("./sqb-entity-service.js"), exports);
+tslib_1.__exportStar(require("./sqb-singleton-resource.js"), exports);

package/cjs/sqb-adapter.js

@@ -4,120 +4,112 @@ exports.SQBAdapter = void 0;
 const tslib_1 = require("tslib");
 const lodash_isnil_1 = tslib_1.__importDefault(require("lodash.isnil"));
 const lodash_omitby_1 = tslib_1.__importDefault(require("lodash.omitby"));
-const convert_filter_js_1 = require("./convert-filter.js");
+const common_1 = require("@opra/common");
+const connect_1 = require("@sqb/connect");
+const transform_filter_js_1 = tslib_1.__importDefault(require("./transform-filter.js"));
+const transform_key_values_js_1 = tslib_1.__importDefault(require("./transform-key-values.js"));
 var SQBAdapter;
 (function (SQBAdapter) {
-    function prepare(query) {
-        switch (query.method) {
-            case 'create': {
-                const options = (0, lodash_omitby_1.default)({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
-                }, lodash_isnil_1.default);
-                const { data } = query;
+    SQBAdapter.transformFilter = transform_filter_js_1.default;
+    SQBAdapter.transformKeyValues = transform_key_values_js_1.default;
+    function transformRequest(request) {
+        const { resource } = request;
+        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
+            const { args, operation } = request;
+            let options = {};
+            const entityMetadata = connect_1.EntityMetadata.get(resource.type.ctor);
+            if (!entityMetadata)
+                throw new Error(`Type class "${resource.type.ctor}" is not an SQB entity`);
+            if (resource instanceof common_1.Collection) {
+                const primaryIndex = entityMetadata.indexes.find(x => x.primary);
+                // Check if resource primary keys are same with entity
+                const primaryKeys = [...(primaryIndex && primaryIndex.columns) || []];
+                if (primaryKeys.sort().join() !== [...resource.primaryKey].sort().join())
+                    throw new Error('Resource primaryKey definition differs from SQB Entity primaryKey definition');
+            }
+            if (operation === 'create' || operation === 'update' ||
+                operation === 'get' || operation === 'findMany') {
+                options.pick = args.pick?.length ? args.pick : undefined;
+                options.omit = args.omit?.length ? args.omit : undefined;
+                options.include = args.include?.length ? args.include : undefined;
+            }
+            if (args.filter) {
+                options.filter = SQBAdapter.transformFilter(args.filter);
+            }
+            if (operation === 'findMany') {
+                options.sort = args.sort?.length ? args.sort : undefined;
+                options.limit = args.limit;
+                options.offset = args.skip;
+                options.distinct = args.distinct;
+                options.count = args.count;
+            }
+            options = (0, lodash_omitby_1.default)(options, lodash_isnil_1.default);
+            if (operation === 'create') {
                 return {
                     method: 'create',
-                    values: data,
+                    data: args.data,
                     options,
-                    args: [data, options]
+                    args: [args.data, options]
                 };
             }
-            case 'count': {
-                const options = (0, lodash_omitby_1.default)({
-                    filter: (0, convert_filter_js_1.convertFilter)(query.filter)
-                }, lodash_isnil_1.default);
+            if (operation === 'deleteMany' || (operation === 'delete' && resource instanceof common_1.Singleton)) {
                 return {
-                    method: 'count',
+                    method: 'deleteMany',
                     options,
                     args: [options]
                 };
             }
-            case 'get': {
-                if (query.kind === 'CollectionGetQuery') {
-                    const options = (0, lodash_omitby_1.default)({
-                        pick: query.pick?.length ? query.pick : undefined,
-                        omit: query.omit?.length ? query.omit : undefined,
-                        include: query.include?.length ? query.include : undefined,
-                    }, lodash_isnil_1.default);
-                    const keyValue = query.keyValue;
-                    return {
-                        method: 'findByPk',
-                        keyValue,
-                        options,
-                        args: [keyValue, options]
-                    };
-                }
-                break;
-            }
-            case 'search': {
-                const options = (0, lodash_omitby_1.default)({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
-                    sort: query.sort?.length ? query.sort : undefined,
-                    limit: query.limit,
-                    offset: query.skip,
-                    distinct: query.distinct,
-                    total: query.count,
-                    filter: (0, convert_filter_js_1.convertFilter)(query.filter)
-                }, lodash_isnil_1.default);
+            if (operation === 'delete') {
                 return {
-                    method: 'findAll',
+                    method: 'delete',
+                    key: args.key,
                     options,
-                    args: [options]
+                    args: [args.key, options]
                 };
             }
-            case 'update': {
-                const options = (0, lodash_omitby_1.default)({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
-                }, lodash_isnil_1.default);
-                const { data } = query;
-                const keyValue = query.keyValue;
+            if (operation === 'get') {
+                if (resource instanceof common_1.Singleton)
+                    return {
+                        method: 'findOne',
+                        options,
+                        args: [options]
+                    };
                 return {
-                    method: 'update',
-                    keyValue: query.keyValue,
-                    values: data,
+                    method: 'find',
+                    key: args.key,
                     options,
-                    args: [keyValue, data, options]
+                    args: [args.key, options]
                 };
             }
-            case 'updateMany': {
-                const options = (0, lodash_omitby_1.default)({
-                    filter: (0, convert_filter_js_1.convertFilter)(query.filter)
-                }, lodash_isnil_1.default);
-                const { data } = query;
-                return {
-                    method: 'updateAll',
-                    values: data,
+            if (operation === 'findMany') {
+                const out = {
+                    method: 'findMany',
                     options,
-                    args: [data, options]
+                    args: [options]
                 };
+                if (args.count)
+                    out.count = args.count;
+                return out;
             }
-            case 'delete': {
-                const options = {};
-                const keyValue = query.keyValue;
+            if (operation === 'updateMany' || (operation === 'update' && resource instanceof common_1.Singleton)) {
                 return {
-                    method: 'destroy',
-                    keyValue,
+                    method: 'updateMany',
+                    data: args.data,
                     options,
-                    args: [keyValue, options]
+                    args: [args.data, options]
                 };
             }
-            case 'deleteMany': {
-                const options = (0, lodash_omitby_1.default)({
-                    filter: (0, convert_filter_js_1.convertFilter)(query.filter)
-                }, lodash_isnil_1.default);
+            if (operation === 'update') {
                 return {
-                    method: 'destroyAll',
+                    method: 'update',
+                    key: args.key,
+                    data: args.data,
                     options,
-                    args: [options]
+                    args: [args.key, args.data, options]
                 };
             }
         }
-        throw new Error(`Unimplemented query method "${query.method}"`);
+        throw new Error(`Unimplemented request method "${request.operation}"`);
     }
-    SQBAdapter.prepare = prepare;
+    SQBAdapter.transformRequest = transformRequest;
 })(SQBAdapter = exports.SQBAdapter || (exports.SQBAdapter = {}));

package/cjs/sqb-collection-resource.js

@@ -0,0 +1,95 @@
+"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 = 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 service.delete(ctx, prepared.key, prepared.options);
+    }
+    async deleteMany(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.deleteMany(ctx, prepared.options);
+    }
+    async find(ctx) {
+        const prepared = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.find(ctx, prepared.key, prepared.options);
+    }
+    async update(ctx) {
+        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 = sqb_adapter_js_1.SQBAdapter.transformRequest(ctx.request);
+        const service = await this.getService(ctx);
+        return service.updateMany(ctx, prepared.data, prepared.options);
+    }
+    async search(ctx) {
+        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([
+                service.findAll(prepared.options),
+                service.count(prepared.options)
+            ]);
+            ctx.response.count = count;
+            return items;
+        }
+        else
+            return service.findAll(ctx, prepared.options);
+    }
+}
+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);
+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);
+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);
+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);
+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);
+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/cjs/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;