@opra/sqb 0.33.13 → 1.0.0-alpha.2

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

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@opra/common");
-const connect_1 = require("@sqb/connect");
-// @ts-ignore
-const _prepareDataTypeInitArguments = common_1.TypeDocumentFactory.prototype.prepareDataTypeInitArguments;
-// @ts-ignore
-common_1.TypeDocumentFactory.prototype.prepareDataTypeInitArguments = async function (schema, ctor) {
-    if (ctor && schema.kind === 'ComplexType' && schema.fields) {
-        const sqbMeta = connect_1.EntityMetadata.get(ctor);
-        for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
-            const sqbField = sqbMeta && connect_1.EntityMetadata.getField(sqbMeta, fieldName);
-            if (!sqbField)
-                continue;
-            const detectType = !fieldSchema.type;
-            if ((0, connect_1.isAssociationField)(sqbField)) {
-                if (!fieldSchema.type) {
-                    const trg = await sqbField.association.resolveTarget();
-                    if (trg) {
-                        fieldSchema.type = await this.importDataType(trg.ctor);
-                    }
-                }
-            }
-            else if (sqbField.kind === 'column') {
-                if (typeof sqbField.enum === 'object')
-                    fieldSchema.enum = sqbField.enum;
-                if (fieldSchema.required == null && sqbField.notNull)
-                    fieldSchema.required = true;
-                if (sqbField.type && Reflect.hasMetadata(common_1.DATATYPE_METADATA, sqbField.type)) {
-                    fieldSchema.type = sqbField.type;
-                }
-                switch (sqbField.dataType) {
-                    case connect_1.DataType.GUID:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'string'))
-                            fieldSchema.type = 'uuid';
-                        break;
-                    case connect_1.DataType.JSON:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'any'))
-                            fieldSchema.type = 'object';
-                        break;
-                    case connect_1.DataType.INTEGER:
-                    case connect_1.DataType.SMALLINT:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'number'))
-                            fieldSchema.type = 'integer';
-                        break;
-                    case connect_1.DataType.BIGINT:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'number'))
-                            fieldSchema.type = 'bigint';
-                        break;
-                    case connect_1.DataType.DATE:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'date';
-                        break;
-                    case connect_1.DataType.TIMESTAMPTZ:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'timestamptz';
-                        break;
-                    case connect_1.DataType.TIME:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'time';
-                        break;
-                    case connect_1.DataType.BINARY:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'string'))
-                            fieldSchema.type = 'base64';
-                        break;
-                }
-                if (!fieldSchema.type) {
-                    switch (sqbField.dataType) {
-                        case connect_1.DataType.BOOL:
-                            fieldSchema.type = 'boolean';
-                            break;
-                        case connect_1.DataType.CHAR:
-                        case connect_1.DataType.VARCHAR:
-                        case connect_1.DataType.TEXT:
-                            fieldSchema.type = 'string';
-                            break;
-                        case connect_1.DataType.FLOAT:
-                        case connect_1.DataType.DOUBLE:
-                        case connect_1.DataType.NUMBER:
-                            fieldSchema.type = 'number';
-                            break;
-                        case connect_1.DataType.TIMESTAMP:
-                            fieldSchema.type = 'datetime';
-                            break;
-                    }
-                }
-                if (sqbField.notNull && fieldSchema.required === undefined)
-                    fieldSchema.required = sqbField.notNull;
-                if (sqbField.exclusive && fieldSchema.exclusive === undefined)
-                    fieldSchema.exclusive = sqbField.exclusive;
-                if (sqbField.default !== undefined && fieldSchema.default === undefined)
-                    fieldSchema.default = sqbField.default;
-            }
-            if (sqbField.exclusive && fieldSchema.exclusive === undefined)
-                fieldSchema.exclusive = sqbField.exclusive;
-        }
-    }
-    return await _prepareDataTypeInitArguments.call(this, schema, ctor);
-};

package/cjs/sqb-collection.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqbCollection = void 0;
-const sqb_adapter_js_1 = require("./sqb-adapter.js");
-// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
-class SqbCollection {
-    constructor(options) {
-        this.defaultLimit = options?.defaultLimit || 100;
-    }
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async deleteMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._deleteMany(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async updateMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._updateMany(ctx, prepared);
-    }
-    async findMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._findMany(ctx, prepared);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.create(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.delete(prepared.key, prepared.options);
-    }
-    async _deleteMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteMany(prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.find(prepared.key, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.update(prepared.key, prepared.data, prepared.options);
-    }
-    async _updateMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateMany(prepared.data, prepared.options);
-    }
-    async _findMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        if (prepared.options.count) {
-            const [items, count] = await Promise.all([
-                service.findMany(prepared.options),
-                service.count(prepared.options)
-            ]);
-            ctx.response.totalMatches = count;
-            return items;
-        }
-        else
-            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-base.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqbEntityServiceBase = void 0;
-const core_1 = require("@opra/core");
-const connect_1 = require("@sqb/connect");
-class SqbEntityServiceBase extends core_1.ApiService {
-    constructor(typeClass, options) {
-        super();
-        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(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(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.transformData)
-            out = this.transformData(out);
-        if (!out)
-            throw new Error('"create" endpoint returned no result!');
-        return out;
-    }
-    async _delete(keyValue, options) {
-        const conn = await this.getConnection();
-        const repo = conn.getRepository(this.typeClass);
-        try {
-            return await repo.delete(keyValue, options) ? 1 : 0;
-        }
-        catch (e) {
-            await this._onError(e);
-            throw e;
-        }
-    }
-    async _deleteMany(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(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.transformData)
-            out = this.transformData(out);
-        return out;
-    }
-    async _findOne(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.transformData)
-            out = this.transformData(out);
-        return out;
-    }
-    async _findMany(options) {
-        const conn = await this.getConnection();
-        const repo = conn.getRepository(this.typeClass);
-        let items;
-        try {
-            items = await repo.findMany(options);
-        }
-        catch (e) {
-            await this._onError(e);
-            throw e;
-        }
-        if (items.length && this.transformData) {
-            const newItems = [];
-            for (const item of items) {
-                const v = this.transformData(item);
-                if (v)
-                    newItems.push(v);
-            }
-            return newItems;
-        }
-        return items;
-    }
-    async _exists(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(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.transformData)
-            out = this.transformData(out);
-        return out;
-    }
-    async _updateMany(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;
-        }
-    }
-    for(context, overwriteProperties, overwriteContext) {
-        return super.for(context, overwriteProperties, overwriteContext);
-    }
-    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.SqbEntityServiceBase = SqbEntityServiceBase;

package/cjs/sqb-singleton.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqbSingleton = void 0;
-const sqb_adapter_js_1 = require("./sqb-adapter.js");
-class SqbSingleton {
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.create(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return await service.deleteMany(prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.findOne(prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        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/cjs/transform-key-values.js

@@ -1,14 +0,0 @@
-"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/esm/augmentation/api-document-factory.augmentation.js

@@ -1,18 +0,0 @@
-import { ApiDocumentFactory } from '@opra/common';
-import { EntityMetadata } from '@sqb/connect';
-// @ts-ignore
-const _createResource = ApiDocumentFactory.prototype.createResource;
-// @ts-ignore
-ApiDocumentFactory.prototype.createResource = function (container, initArguments) {
-    // Determine primaryKey if not defined
-    if (initArguments.kind === 'Collection' && !initArguments.primaryKey && initArguments.type.ctor) {
-        const entityMetadata = EntityMetadata.get(initArguments.type.ctor);
-        if (entityMetadata?.indexes) {
-            const primaryIndex = entityMetadata.indexes.find(x => x.primary);
-            if (primaryIndex) {
-                initArguments.primaryKey = primaryIndex.columns;
-            }
-        }
-    }
-    return _createResource.call(this, container, initArguments);
-};

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

@@ -1,97 +0,0 @@
-import { DATATYPE_METADATA, TypeDocumentFactory } from "@opra/common";
-import { DataType as SqbDataType, EntityMetadata, isAssociationField } from '@sqb/connect';
-// @ts-ignore
-const _prepareDataTypeInitArguments = TypeDocumentFactory.prototype.prepareDataTypeInitArguments;
-// @ts-ignore
-TypeDocumentFactory.prototype.prepareDataTypeInitArguments = async function (schema, ctor) {
-    if (ctor && schema.kind === 'ComplexType' && schema.fields) {
-        const sqbMeta = EntityMetadata.get(ctor);
-        for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
-            const sqbField = sqbMeta && EntityMetadata.getField(sqbMeta, fieldName);
-            if (!sqbField)
-                continue;
-            const detectType = !fieldSchema.type;
-            if (isAssociationField(sqbField)) {
-                if (!fieldSchema.type) {
-                    const trg = await sqbField.association.resolveTarget();
-                    if (trg) {
-                        fieldSchema.type = await this.importDataType(trg.ctor);
-                    }
-                }
-            }
-            else if (sqbField.kind === 'column') {
-                if (typeof sqbField.enum === 'object')
-                    fieldSchema.enum = sqbField.enum;
-                if (fieldSchema.required == null && sqbField.notNull)
-                    fieldSchema.required = true;
-                if (sqbField.type && Reflect.hasMetadata(DATATYPE_METADATA, sqbField.type)) {
-                    fieldSchema.type = sqbField.type;
-                }
-                switch (sqbField.dataType) {
-                    case SqbDataType.GUID:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'string'))
-                            fieldSchema.type = 'uuid';
-                        break;
-                    case SqbDataType.JSON:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'any'))
-                            fieldSchema.type = 'object';
-                        break;
-                    case SqbDataType.INTEGER:
-                    case SqbDataType.SMALLINT:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'number'))
-                            fieldSchema.type = 'integer';
-                        break;
-                    case SqbDataType.BIGINT:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'number'))
-                            fieldSchema.type = 'bigint';
-                        break;
-                    case SqbDataType.DATE:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'date';
-                        break;
-                    case SqbDataType.TIMESTAMPTZ:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'timestamptz';
-                        break;
-                    case SqbDataType.TIME:
-                        if (!fieldSchema.type || (detectType && (fieldSchema.type === 'datetime' || fieldSchema.type === 'string')))
-                            fieldSchema.type = 'time';
-                        break;
-                    case SqbDataType.BINARY:
-                        if (!fieldSchema.type || (detectType && fieldSchema.type === 'string'))
-                            fieldSchema.type = 'base64';
-                        break;
-                }
-                if (!fieldSchema.type) {
-                    switch (sqbField.dataType) {
-                        case SqbDataType.BOOL:
-                            fieldSchema.type = 'boolean';
-                            break;
-                        case SqbDataType.CHAR:
-                        case SqbDataType.VARCHAR:
-                        case SqbDataType.TEXT:
-                            fieldSchema.type = 'string';
-                            break;
-                        case SqbDataType.FLOAT:
-                        case SqbDataType.DOUBLE:
-                        case SqbDataType.NUMBER:
-                            fieldSchema.type = 'number';
-                            break;
-                        case SqbDataType.TIMESTAMP:
-                            fieldSchema.type = 'datetime';
-                            break;
-                    }
-                }
-                if (sqbField.notNull && fieldSchema.required === undefined)
-                    fieldSchema.required = sqbField.notNull;
-                if (sqbField.exclusive && fieldSchema.exclusive === undefined)
-                    fieldSchema.exclusive = sqbField.exclusive;
-                if (sqbField.default !== undefined && fieldSchema.default === undefined)
-                    fieldSchema.default = sqbField.default;
-            }
-            if (sqbField.exclusive && fieldSchema.exclusive === undefined)
-                fieldSchema.exclusive = sqbField.exclusive;
-        }
-    }
-    return await _prepareDataTypeInitArguments.call(this, schema, ctor);
-};

package/esm/sqb-collection.js

@@ -1,76 +0,0 @@
-import { SQBAdapter } from './sqb-adapter.js';
-// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
-export class SqbCollection {
-    constructor(options) {
-        this.defaultLimit = options?.defaultLimit || 100;
-    }
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async deleteMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._deleteMany(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async updateMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._updateMany(ctx, prepared);
-    }
-    async findMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._findMany(ctx, prepared);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.create(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.delete(prepared.key, prepared.options);
-    }
-    async _deleteMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteMany(prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.find(prepared.key, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.update(prepared.key, prepared.data, prepared.options);
-    }
-    async _updateMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateMany(prepared.data, prepared.options);
-    }
-    async _findMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        if (prepared.options.count) {
-            const [items, count] = await Promise.all([
-                service.findMany(prepared.options),
-                service.count(prepared.options)
-            ]);
-            ctx.response.totalMatches = count;
-            return items;
-        }
-        else
-            return service.findMany(prepared.options);
-    }
-    async _prepare(ctx) {
-        const prepared = SQBAdapter.transformRequest(ctx.request);
-        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
-    }
-}