@minimaltech/node-infra 0.5.9-22 → 0.5.9-24

package/dist/base/models/base.model.js

@@ -12,67 +12,83 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseVectorEntity = exports.BaseBigIdTzEntity = exports.BaseBigIdEntity = exports.BaseDuplicatableTzEntity = exports.BaseSoftDeleteTzEntity = exports.BaseSearchableTzEntity = exports.BaseObjectSearchTzEntity = exports.BaseTextSearchTzEntity = exports.BaseDataTypeTzEntity = exports.BaseUserAuditTzEntity = exports.BaseTzEntity = exports.BaseKVEntity = exports.BaseStringIdEntity = exports.BaseNumberIdEntity = exports.BaseIdEntity = exports.BaseEntity = void 0;
 const mixins_1 = require("../../mixins");
 const repository_1 = require("@loopback/repository");
+// ---------------------------------------------------------------------
 class BaseEntity extends repository_1.Entity {
 }
 exports.BaseEntity = BaseEntity;
+// ---------------------------------------------------------------------
 class BaseIdEntity extends BaseEntity {
-    id;
 }
 exports.BaseIdEntity = BaseIdEntity;
 __decorate([
     (0, repository_1.property)({ type: 'number', id: true, generated: true }),
     __metadata("design:type", Number)
 ], BaseIdEntity.prototype, "id", void 0);
+// ---------------------------------------------------------------------
 class BaseNumberIdEntity extends BaseEntity {
-    id;
 }
 exports.BaseNumberIdEntity = BaseNumberIdEntity;
 __decorate([
     (0, repository_1.property)({ type: 'number', id: true, generated: true }),
     __metadata("design:type", Number)
 ], BaseNumberIdEntity.prototype, "id", void 0);
+// ---------------------------------------------------------------------
 class BaseStringIdEntity extends BaseEntity {
-    id;
 }
 exports.BaseStringIdEntity = BaseStringIdEntity;
 __decorate([
     (0, repository_1.property)({ type: 'string', id: true }),
     __metadata("design:type", String)
 ], BaseStringIdEntity.prototype, "id", void 0);
+// ---------------------------------------------------------------------
 class BaseKVEntity extends BaseEntity {
-    payload;
 }
 exports.BaseKVEntity = BaseKVEntity;
 __decorate([
     (0, repository_1.property)({ type: 'object' }),
     __metadata("design:type", Object)
 ], BaseKVEntity.prototype, "payload", void 0);
+// ---------------------------------------------------------------------
 class BaseTzEntity extends (0, mixins_1.TzMixin)(BaseIdEntity) {
 }
 exports.BaseTzEntity = BaseTzEntity;
+// ---------------------------------------------------------------------
+/**
+ * Basic UserAuditMixed class with createdBy and modifiedBy
+ *
+ * NOTICE: This method have no userResolver
+ *
+ * In case you need to include User, directly extends {@link UserAuditMixin}
+ */
 class BaseUserAuditTzEntity extends (0, mixins_1.UserAuditMixin)(BaseTzEntity) {
 }
 exports.BaseUserAuditTzEntity = BaseUserAuditTzEntity;
+// ---------------------------------------------------------------------
 class BaseDataTypeTzEntity extends (0, mixins_1.DataTypeMixin)(BaseTzEntity) {
 }
 exports.BaseDataTypeTzEntity = BaseDataTypeTzEntity;
+// ---------------------------------------------------------------------
 class BaseTextSearchTzEntity extends (0, mixins_1.TextSearchMixin)(BaseTzEntity) {
 }
 exports.BaseTextSearchTzEntity = BaseTextSearchTzEntity;
+// ---------------------------------------------------------------------
 class BaseObjectSearchTzEntity extends (0, mixins_1.ObjectSearchMixin)(BaseTzEntity) {
 }
 exports.BaseObjectSearchTzEntity = BaseObjectSearchTzEntity;
+// ---------------------------------------------------------------------
 class BaseSearchableTzEntity extends (0, mixins_1.ObjectSearchMixin)((0, mixins_1.TextSearchMixin)(BaseTzEntity)) {
 }
 exports.BaseSearchableTzEntity = BaseSearchableTzEntity;
+// ---------------------------------------------------------------------
 class BaseSoftDeleteTzEntity extends (0, mixins_1.SoftDeleteModelMixin)(BaseTzEntity) {
 }
 exports.BaseSoftDeleteTzEntity = BaseSoftDeleteTzEntity;
+// ---------------------------------------------------------------------
 class BaseDuplicatableTzEntity extends (0, mixins_1.DuplicatableMixin)(BaseTzEntity) {
 }
 exports.BaseDuplicatableTzEntity = BaseDuplicatableTzEntity;
+// ---------------------------------------------------------------------
 class BaseBigIdEntity extends BaseEntity {
-    id;
 }
 exports.BaseBigIdEntity = BaseBigIdEntity;
 __decorate([
@@ -83,9 +99,11 @@ __decorate([
     }),
     __metadata("design:type", Number)
 ], BaseBigIdEntity.prototype, "id", void 0);
+// ---------------------------------------------------------------------
 class BaseBigIdTzEntity extends (0, mixins_1.TzMixin)(BaseBigIdEntity) {
 }
 exports.BaseBigIdTzEntity = BaseBigIdTzEntity;
+// ---------------------------------------------------------------------
 class BaseVectorEntity extends (0, mixins_1.VectorMixin)(BaseBigIdTzEntity, {
     uuid: {
         columnName: 'uuid',

package/dist/base/repositories/base.repository.d.ts

@@ -8,6 +8,9 @@ export declare class WhereBuilder<E extends object = AnyObject> extends BaseWher
     clone(): WhereBuilder;
 }
 export declare class DefaultCrudRepository<E extends BaseEntity, ID, Relations extends object = {}> extends _DefaultCrudRepository<E, ID, Relations> {
+    /**
+     * @experimental
+     */
     createHasManyPolymorphicRepositoryFactoryFor<Target extends BaseEntity, TargetId extends IdType, ForeignKeyType extends IdType>(opts: {
         relationName: string;
         principalType: string;

package/dist/base/repositories/base.repository.js

@@ -1,4 +1,15 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,6 +21,7 @@ const repository_1 = require("@loopback/repository");
 const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const get_1 = __importDefault(require("lodash/get"));
 const factory_1 = require("./relations/has-many-polymorphic/factory");
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class WhereBuilder extends repository_1.WhereBuilder {
     constructor(opts) {
         super(opts);
@@ -22,7 +34,11 @@ class WhereBuilder extends repository_1.WhereBuilder {
     }
 }
 exports.WhereBuilder = WhereBuilder;
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class DefaultCrudRepository extends repository_1.DefaultCrudRepository {
+    /**
+     * @experimental
+     */
     createHasManyPolymorphicRepositoryFactoryFor(opts) {
         const { relationName, principalType, targetRepositoryGetter } = opts;
         const relationMetadata = this.entityClass.definition.relations[relationName];
@@ -39,16 +55,16 @@ class DefaultCrudRepository extends repository_1.DefaultCrudRepository {
     }
 }
 exports.DefaultCrudRepository = DefaultCrudRepository;
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class AbstractTzRepository extends DefaultCrudRepository {
-    logger;
     constructor(entityClass, dataSource, scope) {
         super(entityClass, dataSource);
-        this.logger = helpers_1.LoggerFactory.getLogger([scope ?? '']);
+        this.logger = helpers_1.LoggerFactory.getLogger([scope !== null && scope !== void 0 ? scope : '']);
     }
     beginTransaction(options) {
         return new Promise((resolve, reject) => {
             this.dataSource
-                .beginTransaction(options ?? {})
+                .beginTransaction(options !== null && options !== void 0 ? options : {})
                 .then(rs => {
                 resolve(rs);
             })
@@ -63,24 +79,27 @@ class AbstractTzRepository extends DefaultCrudRepository {
         return (0, get_1.default)(this.modelClass, `_observers.${operation}`, []);
     }
     notifyObservers(opts) {
-        const { operation, ...rest } = opts;
+        const { operation } = opts, rest = __rest(opts, ["operation"]);
         const observers = this.getObservers({ operation });
-        observers.forEach(observer => observer({ ...this.modelClass, ...rest }));
+        observers.forEach(observer => observer(Object.assign(Object.assign({}, this.modelClass), rest)));
     }
 }
 exports.AbstractTzRepository = AbstractTzRepository;
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class AbstractKVRepository extends repository_1.DefaultKeyValueRepository {
     constructor(entityClass, dataSource) {
         super(entityClass, dataSource);
     }
 }
 exports.AbstractKVRepository = AbstractKVRepository;
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class KVRepository extends AbstractKVRepository {
     constructor(entityClass, dataSource) {
         super(entityClass, dataSource);
     }
 }
 exports.KVRepository = KVRepository;
+// ----------------------------------------------------------------------------------------------------------------------------------------
 class ViewRepository extends DefaultCrudRepository {
     constructor(entityClass, dataSource) {
         super(entityClass, dataSource);

package/dist/base/repositories/relations/has-many-polymorphic/decorator.d.ts

@@ -1,4 +1,12 @@
 import { Entity } from '@loopback/repository';
 import { IHasManyPolymorphicDefinition } from './types';
 import { ValueOptionalExcept } from '../../../../common';
+/**
+ * Custom decorator to define a polymorphic `@hasManyPolymorphic` relationship
+ *
+ * @param targetModelGetter - A function to return the target model constructor
+ * @param definition - Additional relation metadata
+ *
+ * @experimental
+ */
 export declare function hasManyPolymorphic(definition: ValueOptionalExcept<IHasManyPolymorphicDefinition, 'target'>): (decoratedTarget: Entity, key: string) => void;

package/dist/base/repositories/relations/has-many-polymorphic/decorator.js

@@ -2,20 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasManyPolymorphic = hasManyPolymorphic;
 const repository_1 = require("@loopback/repository");
+/**
+ * Custom decorator to define a polymorphic `@hasManyPolymorphic` relationship
+ *
+ * @param targetModelGetter - A function to return the target model constructor
+ * @param definition - Additional relation metadata
+ *
+ * @experimental
+ */
 function hasManyPolymorphic(definition) {
     return (decoratedTarget, key) => {
-        const meta = {
-            name: key,
-            type: repository_1.RelationType.hasMany,
-            targetsMany: true,
-            source: decoratedTarget.constructor,
-            keyFrom: 'id',
-            keyTo: 'principalId',
-            polymorphic: {
+        const meta = Object.assign({ name: key, type: repository_1.RelationType.hasMany, targetsMany: true, source: decoratedTarget.constructor, keyFrom: 'id', keyTo: 'principalId', polymorphic: {
                 discriminator: 'principal',
-            },
-            ...definition,
-        };
+            } }, definition);
         (0, repository_1.relation)(meta)(decoratedTarget, key);
     };
 }

package/dist/base/repositories/relations/has-many-polymorphic/factory.d.ts

@@ -3,6 +3,9 @@ import { IdType } from '../../../../common';
 import { Getter } from '@loopback/core';
 import { DefaultHasManyRepository, Entity, EntityCrudRepository, HasManyRepositoryFactory, InclusionResolver } from '@loopback/repository';
 import { IHasManyPolymorphicDefinition, TPolymorphic } from './types';
+/**
+ * @experimental
+ */
 export declare class DefaultHasManyPolymorphicRepository<Target extends BaseEntity, TargetId extends IdType, TargetRepository extends EntityCrudRepository<Target, TargetId>, SourceId> extends DefaultHasManyRepository<Target, TargetId, TargetRepository> {
     constructor(opts: {
         targetRepositoryGetter: Getter<TargetRepository>;
@@ -12,11 +15,17 @@ export declare class DefaultHasManyPolymorphicRepository<Target extends BaseEnti
         };
     });
 }
+/**
+ * @experimental
+ */
 export declare const createHasManyPolymorphicInclusionResolver: <Target extends BaseEntity, TargetId extends IdType, TargetRelations extends object>(opts: {
     principalType: string;
     relationMetadata: IHasManyPolymorphicDefinition;
     targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetId, TargetRelations>>;
 }) => InclusionResolver<Entity, Target>;
+/**
+ * @experimental
+ */
 export declare const createHasManyPolymorphicRepositoryFactoryFor: <Target extends BaseEntity, TargetId extends IdType, SourceId extends IdType>(opts: {
     principalType: string;
     relationMetadata: IHasManyPolymorphicDefinition;

package/dist/base/repositories/relations/has-many-polymorphic/factory.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,6 +17,7 @@ const utilities_1 = require("../../../../utilities");
 const repository_1 = require("@loopback/repository");
 const get_1 = __importDefault(require("lodash/get"));
 const base_repository_1 = require("../../base.repository");
+// ----------------------------------------------------------------------------------------------------------------------------------------
 const getPolymorphicFields = (opts) => {
     const { discriminator } = opts;
     let typeField = null;
@@ -32,6 +42,10 @@ const getPolymorphicFields = (opts) => {
     }
     return { typeField, idField };
 };
+// ----------------------------------------------------------------------------------------------------------------------------------------
+/**
+ * @experimental
+ */
 class DefaultHasManyPolymorphicRepository extends repository_1.DefaultHasManyRepository {
     constructor(opts) {
         const { targetRepositoryGetter, polymorphic } = opts;
@@ -43,9 +57,14 @@ class DefaultHasManyPolymorphicRepository extends repository_1.DefaultHasManyRep
     }
 }
 exports.DefaultHasManyPolymorphicRepository = DefaultHasManyPolymorphicRepository;
+// ----------------------------------------------------------------------------------------------------------------------------------------
+/**
+ * @experimental
+ */
 const createHasManyPolymorphicInclusionResolver = (opts) => {
     const { principalType, relationMetadata, targetRepositoryGetter } = opts;
-    return async (entities, inclusion, options) => {
+    return (entities, inclusion, options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
         if (!entities.length) {
             return [];
         }
@@ -59,27 +78,26 @@ const createHasManyPolymorphicInclusionResolver = (opts) => {
         const sourceIds = entities.map(e => (0, get_1.default)(e, sourceKey));
         const targetKey = polymorphicFields.idField;
         const scope = typeof inclusion === 'string' ? {} : inclusion.scope;
-        const targetRepository = await targetRepositoryGetter();
-        const filter = {
-            ...scope,
-            where: new base_repository_1.WhereBuilder({
-                ...(scope?.where ?? {}),
-            })
+        const targetRepository = yield targetRepositoryGetter();
+        const filter = Object.assign(Object.assign({}, scope), { where: new base_repository_1.WhereBuilder(Object.assign({}, ((_a = scope === null || scope === void 0 ? void 0 : scope.where) !== null && _a !== void 0 ? _a : {})))
                 .inq(polymorphicFields.idField, sourceIds)
                 .eq(polymorphicFields.typeField, principalType)
-                .build(),
-        };
-        const targets = await targetRepository.find(filter, options);
+                .build() });
+        const targets = yield targetRepository.find(filter, options);
         return (0, repository_1.flattenTargetsOfOneToManyRelation)(sourceIds, targets, targetKey);
-    };
+    });
 };
 exports.createHasManyPolymorphicInclusionResolver = createHasManyPolymorphicInclusionResolver;
+// ----------------------------------------------------------------------------------------------------------------------------------------
+/**
+ * @experimental
+ */
 const createHasManyPolymorphicRepositoryFactoryFor = (opts) => {
     const { principalType, relationMetadata, targetRepositoryGetter } = opts;
     const rs = (sourceId) => {
         return new DefaultHasManyPolymorphicRepository({
             targetRepositoryGetter,
-            polymorphic: { ...relationMetadata.polymorphic, typeValue: principalType, idValue: sourceId },
+            polymorphic: Object.assign(Object.assign({}, relationMetadata.polymorphic), { typeValue: principalType, idValue: sourceId }),
         });
     };
     rs.inclusionResolver = (0, exports.createHasManyPolymorphicInclusionResolver)(opts);