@opra/sqb 1.20.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/sqb",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -10,45 +10,28 @@
     "valgen": "^5.18.2"
   },
   "peerDependencies": {
-    "@opra/core": "^1.20.0",
-    "@opra/http": "^1.20.0",
+    "@opra/core": "^1.22.0",
+    "@opra/http": "^1.22.0",
     "@sqb/connect": "^4.20.4"
   },
   "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": {
-        "types": "./types/index.d.cts",
-        "default": "./cjs/index.js"
-      },
-      "default": "./esm/index.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/panates/opra.git",
     "directory": "packages/sqb"
   },
-  "engines": {
-    "node": ">=16.0",
-    "npm": ">=7.0.0"
-  },
-  "files": [
-    "bin/",
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "opra",
     "sqb",

package/{types/sqb-collection-service.d.ts → sqb-collection-service.d.ts}

@@ -91,7 +91,7 @@ export declare namespace SqbCollectionService {
  * @class SqbCollectionService
  * @template T - The data type class type of the resource
  */
-export declare class SqbCollectionService<T extends object = object> extends SqbEntityService {
+export declare class SqbCollectionService<T extends object = object> extends SqbEntityService<T> {
     /**
      * Represents default limit for findMany operation
      */

package/{esm/sqb-collection-service.js → sqb-collection-service.js}

@@ -6,6 +6,10 @@ import { SqbEntityService } from './sqb-entity-service.js';
  * @template T - The data type class type of the resource
  */
 export class SqbCollectionService extends SqbEntityService {
+    /**
+     * Represents default limit for findMany operation
+     */
+    defaultLimit;
     /**
      * Constructs a new instance
      *

package/{esm/sqb-entity-service.js → sqb-entity-service.js}

@@ -9,6 +9,35 @@ import { SqbServiceBase } from './sqb-service-base.js';
  * @template T - The data type class type of the resource
  */
 export class SqbEntityService extends SqbServiceBase {
+    _dataTypeScope;
+    _dataType_;
+    _dataType;
+    _dataTypeClass;
+    _entityMetadata;
+    _inputCodecs = {};
+    _outputCodecs = {};
+    /**
+     * Defines comma delimited scopes for api document
+     */
+    scope;
+    /**
+     * Represents the name of a resource.
+     * @type {string}
+     */
+    resourceName;
+    /**
+     * Represents a common filter function for a service.
+     *
+     * @type {SqbEntityService.Filter | Function}
+     */
+    commonFilter;
+    /**
+     * Callback function for handling errors.
+     *
+     * @param {unknown} error - The error object.
+     * @param {SqbEntityService} _this - The context object.
+     */
+    onError;
     /**
      * Constructs a new instance
      *
@@ -18,8 +47,6 @@ export class SqbEntityService extends SqbServiceBase {
      */
     constructor(dataType, options) {
         super(options);
-        this._inputCodecs = {};
-        this._outputCodecs = {};
         this._dataType_ = dataType;
         this.resourceName = options?.resourceName;
         this.commonFilter = options?.commonFilter;

package/{esm/sqb-service-base.js → sqb-service-base.js}

@@ -6,6 +6,10 @@ const transactionKey = Symbol.for('transaction');
  * @template T - The data type class type of the resource
  */
 export class SqbServiceBase extends ServiceBase {
+    /**
+     * Represents a SqbClient or SqbConnection object
+     */
+    db;
     /**
      * Constructs a new instance
      *

package/{types/sqb-singleton-service.d.ts → sqb-singleton-service.d.ts}

@@ -55,7 +55,7 @@ export declare namespace SqbSingletonService {
  * @class SqbSingletonService
  * @template T - The data type class type of the resource
  */
-export declare class SqbSingletonService<T extends object = object> extends SqbEntityService {
+export declare class SqbSingletonService<T extends object = object> extends SqbEntityService<T> {
     /**
      * Represents a unique identifier for singleton record
      * @property {SQBAdapter.IdOrIds}

package/{esm/sqb-singleton-service.js → sqb-singleton-service.js}

@@ -7,6 +7,11 @@ import { SqbEntityService } from './sqb-entity-service.js';
  * @template T - The data type class type of the resource
  */
 export class SqbSingletonService extends SqbEntityService {
+    /**
+     * Represents a unique identifier for singleton record
+     * @property {SQBAdapter.IdOrIds}
+     */
+    id;
     /**
      * Constructs a new instance
      *

package/cjs/adapter-utils/prepare-filter.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareFilter;
-const tslib_1 = require("tslib");
-require("@opra/core");
-const common_1 = require("@opra/common");
-const sqb = tslib_1.__importStar(require("@sqb/builder"));
-const valgen_1 = require("valgen");
-/**
- * Prepare the SQB filter based on the provided filters and options.
- *
- * @param {SQBAdapter.FilterInput|SQBAdapter.FilterInput[]} filters - The filter(s) to be applied.
- *
- * @returns {Expression} - The prepared SQB Expression.
- */
-function prepareFilter(filters) {
-    const filtersArray = Array.isArray(filters) ? filters : [filters];
-    if (!filtersArray.length)
-        return undefined;
-    const arr = [];
-    for (const filter of filtersArray) {
-        if (!filter)
-            continue;
-        let ast;
-        if (typeof filter === 'string')
-            ast = prepareFilterAst(common_1.OpraFilter.parse(filter));
-        else if (filter instanceof common_1.OpraFilter.Expression)
-            ast = prepareFilterAst(filter);
-        else
-            ast = filter;
-        if (ast)
-            arr.push(ast);
-    }
-    return arr.length > 1 ? sqb.And(...arr) : arr[0];
-}
-const _isDate = valgen_1.vg.isDate({ trim: 'day' });
-const _isDateTime = valgen_1.vg.isDate();
-function prepareFilterAst(ast) {
-    if (!ast)
-        return;
-    if (ast instanceof common_1.OpraFilter.DateLiteral) {
-        return _isDate(ast.value, { coerce: true });
-    }
-    if (ast instanceof common_1.OpraFilter.DateTimeLiteral) {
-        return _isDateTime(ast.value, { coerce: true });
-    }
-    if (ast instanceof common_1.OpraFilter.ArrayExpression) {
-        return ast.items.map(prepareFilterAst);
-    }
-    if (ast instanceof common_1.OpraFilter.NegativeExpression) {
-        return sqb.Not(prepareFilterAst(ast.expression));
-    }
-    if (ast instanceof common_1.OpraFilter.LogicalExpression) {
-        if (ast.op === 'or')
-            return sqb.Or(...ast.items.map(prepareFilterAst));
-        return sqb.And(...ast.items.map(prepareFilterAst));
-    }
-    if (ast instanceof common_1.OpraFilter.ParenthesizedExpression) {
-        return prepareFilterAst(ast.expression);
-    }
-    if (ast instanceof common_1.OpraFilter.ComparisonExpression) {
-        const left = String(ast.left);
-        const right = prepareFilterAst(ast.right);
-        if (ast.prepare) {
-            const x = ast.prepare({
-                left,
-                right,
-                op: ast.op,
-                adapter: 'sqb',
-            });
-            if (x)
-                return x;
-        }
-        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, String(right).replace(/\*/g, '%'));
-            case 'ilike':
-                return sqb.Ilike(left, String(right).replace(/\*/g, '%'));
-            case '!like':
-                return sqb.NotLike(left, String(right).replace(/\*/g, '%'));
-            case '!ilike':
-                return sqb.NotILike(left, String(right).replace(/\*/g, '%'));
-            default:
-                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
-        }
-    }
-    if (ast instanceof common_1.OpraFilter.QualifiedIdentifier ||
-        ast instanceof common_1.OpraFilter.Literal) {
-        return ast.value;
-    }
-    throw new Error(`${ast.kind} is not implemented yet`);
-}

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

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@opra/common");
-const connect_1 = require("@sqb/connect");
-var DataTypeFactory = common_1.classes.DataTypeFactory;
-const _prepareComplexTypeArgs = DataTypeFactory
-    ._prepareComplexTypeArgs;
-DataTypeFactory._prepareComplexTypeArgs = async function (context, owner, initArgs, metadata) {
-    let sqbMeta;
-    if (initArgs.ctor &&
-        metadata.fields &&
-        (sqbMeta = connect_1.EntityMetadata.get(initArgs.ctor))) {
-        metadata = (0, common_1.cloneObject)(metadata);
-        for (const [fieldName, fieldSchema] of Object.entries(metadata.fields)) {
-            const sqbField = sqbMeta && connect_1.EntityMetadata.getField(sqbMeta, fieldName);
-            if (!sqbField)
-                continue;
-            /** Copy type information from sqb metadata to opra */
-            if (!fieldSchema.type || fieldSchema.type === Object) {
-                if ((0, connect_1.isAssociationField)(sqbField)) {
-                    if (!fieldSchema.type) {
-                        const trg = await sqbField.association.resolveTarget();
-                        if (trg?.ctor)
-                            fieldSchema.type = trg.ctor;
-                    }
-                }
-                else if ((0, connect_1.isColumnField)(sqbField)) {
-                    fieldSchema.type = sqbField.enum || sqbField.type;
-                }
-            }
-            if ((0, connect_1.isColumnField)(sqbField)) {
-                const hasNoType = !fieldSchema.type || fieldSchema.type === Object;
-                switch (sqbField.dataType) {
-                    case connect_1.DataType.INTEGER:
-                    case connect_1.DataType.SMALLINT:
-                        if (hasNoType || fieldSchema.type === Number)
-                            fieldSchema.type = 'integer';
-                        break;
-                    case connect_1.DataType.GUID:
-                        if (hasNoType || fieldSchema.type === String)
-                            fieldSchema.type = 'uuid';
-                        break;
-                    case connect_1.DataType.DATE:
-                        if (hasNoType ||
-                            fieldSchema.type === String ||
-                            fieldSchema.type === Date) {
-                            fieldSchema.type = 'date';
-                        }
-                        break;
-                    case connect_1.DataType.TIMESTAMP:
-                        if (hasNoType ||
-                            fieldSchema.type === String ||
-                            fieldSchema.type === Date) {
-                            fieldSchema.type = 'datetime';
-                        }
-                        break;
-                    case connect_1.DataType.TIMESTAMPTZ:
-                        if (hasNoType ||
-                            fieldSchema.type === String ||
-                            fieldSchema.type === Date) {
-                            fieldSchema.type = 'datetimetz';
-                        }
-                        break;
-                    case connect_1.DataType.TIME:
-                        if (hasNoType || fieldSchema.type === String)
-                            fieldSchema.type = 'time';
-                        break;
-                    default:
-                        break;
-                }
-            }
-            if ((0, connect_1.isAssociationField)(sqbField)) {
-                if (sqbField.association.returnsMany())
-                    fieldSchema.isArray = true;
-                if (!Object.prototype.hasOwnProperty.call(fieldSchema, 'exclusive'))
-                    fieldSchema.exclusive = true;
-            }
-            if (!Object.prototype.hasOwnProperty.call(fieldSchema, 'exclusive') &&
-                Object.prototype.hasOwnProperty.call(sqbField, 'exclusive')) {
-                fieldSchema.exclusive = sqbField.exclusive;
-            }
-        }
-    }
-    return _prepareComplexTypeArgs.apply(DataTypeFactory, [
-        context,
-        owner,
-        initArgs,
-        metadata,
-    ]);
-};

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

@@ -1,14 +0,0 @@
-"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 (targetType, sourceType, options) {
-    _applyMixin.call(null, targetType, sourceType, options);
-    const srcMeta = connect_1.Entity.getMetadata(sourceType);
-    if (srcMeta) {
-        const trgMeta = connect_1.EntityMetadata.define(targetType);
-        const { isInheritedPredicate } = options;
-        connect_1.EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
-    }
-};

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@opra/common");
-const connect_1 = require("@sqb/connect");
-const oldDecorator = common_1.MixinType[common_1.DECORATOR];
-common_1.MixinType[common_1.DECORATOR] = function (...args) {
-    const filteredSources = args[0].filter(x => typeof x === 'function');
-    const target = oldDecorator(...args);
-    connect_1.Entity.mixin(target, ...filteredSources);
-    return target;
-};

package/cjs/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-require("./augmentation/datatype-factory.augmentation.js");
-require("./augmentation/mapped-type.augmentation.js");
-require("./augmentation/mixin-type.augmentation.js");
-tslib_1.__exportStar(require("./sqb-adapter.js"), exports);
-tslib_1.__exportStar(require("./sqb-collection-service.js"), exports);
-tslib_1.__exportStar(require("./sqb-entity-service.js"), exports);
-tslib_1.__exportStar(require("./sqb-service-base.js"), exports);
-tslib_1.__exportStar(require("./sqb-singleton-service.js"), exports);

package/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/cjs/sqb-adapter.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQBAdapter = void 0;
-const tslib_1 = require("tslib");
-const connect_1 = require("@sqb/connect");
-const prepare_filter_js_1 = tslib_1.__importDefault(require("./adapter-utils/prepare-filter.js"));
-var SQBAdapter;
-(function (SQBAdapter) {
-    /**
-     * @deprecated Use prepareFilter instead
-     */
-    SQBAdapter.parseFilter = prepare_filter_js_1.default;
-    SQBAdapter.prepareFilter = prepare_filter_js_1.default;
-    async function parseRequest(context) {
-        if (context.transport !== 'http') {
-            throw new TypeError('SQBAdapter can parse only HttpContext');
-        }
-        const ctx = context;
-        const { __oprDef } = ctx;
-        if (__oprDef?.composition?.startsWith('Entity.') &&
-            __oprDef.compositionOptions?.type) {
-            const dataType = ctx.__docNode.getComplexType(__oprDef.compositionOptions?.type);
-            const entityMetadata = connect_1.EntityMetadata.get(dataType.ctor);
-            if (!entityMetadata)
-                throw new Error(`Type class "${dataType.ctor}" is not an SQB entity`);
-            const controller = __oprDef.owner;
-            switch (__oprDef.composition) {
-                case 'Entity.Create': {
-                    const data = await ctx.getBody();
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                    };
-                    return {
-                        method: 'create',
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.Delete': {
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                    };
-                    return {
-                        method: 'delete',
-                        key,
-                        options,
-                    };
-                }
-                case 'Entity.DeleteMany': {
-                    const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                    };
-                    return { method: 'deleteMany', options };
-                }
-                case 'Entity.FindMany': {
-                    const options = {
-                        count: ctx.queryParams.count,
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                        projection: ctx.queryParams.projection ||
-                            __oprDef.compositionOptions.defaultProjection,
-                        limit: ctx.queryParams.limit || __oprDef.compositionOptions.defaultLimit,
-                        skip: ctx.queryParams.skip,
-                        sort: ctx.queryParams.sort || __oprDef.compositionOptions.defaultSort,
-                    };
-                    return { method: 'findMany', options };
-                }
-                case 'Entity.Get': {
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                    };
-                    return { method: 'get', key, options };
-                }
-                case 'Entity.Replace': {
-                    const data = await ctx.getBody();
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: ctx.queryParams.filter,
-                    };
-                    return {
-                        method: 'replace',
-                        key,
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.Update': {
-                    const data = await ctx.getBody();
-                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
-                        controller.parameters.find(p => p.keyParam);
-                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
-                    const options = {
-                        projection: ctx.queryParams.projection,
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                    };
-                    return {
-                        method: 'update',
-                        key,
-                        data,
-                        options,
-                    };
-                }
-                case 'Entity.UpdateMany': {
-                    const data = await ctx.getBody();
-                    const options = {
-                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
-                    };
-                    return {
-                        method: 'updateMany',
-                        data,
-                        options,
-                    };
-                }
-                default:
-                    break;
-            }
-        }
-        throw new Error(`This operation is not compatible to SQB Adapter`);
-    }
-    SQBAdapter.parseRequest = parseRequest;
-})(SQBAdapter || (exports.SQBAdapter = SQBAdapter = {}));