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

package/dist/base/controllers/common.d.ts

@@ -1,8 +1,8 @@
 import { Filter } from '@loopback/repository';
 import { IController } from '../../common';
 import { ApplicationLogger } from '../../helpers';
-import { BaseTzEntity } from './../models';
-export declare const applyLimit: <E extends BaseTzEntity>(filter?: Filter<E>) => Filter<E>;
+import { BaseEntity } from '../models';
+export declare const applyLimit: <E extends BaseEntity>(filter?: Filter<E>) => Filter<E>;
 export declare class BaseController implements IController {
     logger: ApplicationLogger;
     defaultLimit: number;

package/dist/base/controllers/crud.controller.d.ts

@@ -1,12 +1,13 @@
 import { Getter } from '@loopback/core';
-import { CrudRestControllerOptions } from '@loopback/rest-crud';
 import { Count, Filter, FilterExcludingWhere, Where } from '@loopback/repository';
 import { SchemaRef } from '@loopback/rest';
-import { BaseIdEntity, BaseTzEntity, AbstractTzRepository } from './../';
+import { CrudRestControllerOptions } from '@loopback/rest-crud';
 import { EntityRelationType, IdType } from '../../common/types';
 import { IJWTTokenPayload } from '../../components/authenticate/common/types';
-export interface ICrudControllerOptions<E extends BaseIdEntity> {
-    entity: typeof BaseIdEntity & {
+import { BaseEntity } from '../models';
+import { DefaultCrudRepository } from '../repositories';
+export interface ICrudControllerOptions<E extends BaseEntity> {
+    entity: typeof BaseEntity & {
         prototype: E;
     };
     repository: {
@@ -30,9 +31,9 @@ export interface ICrudControllerOptions<E extends BaseIdEntity> {
     };
     doInjectCurrentUser?: boolean;
 }
-export declare const defineCrudController: <E extends BaseTzEntity>(opts: ICrudControllerOptions<E>) => {
-    new (repository: AbstractTzRepository<E, EntityRelationType>): {
-        repository: AbstractTzRepository<E, EntityRelationType>;
+export declare const defineCrudController: <E extends BaseEntity>(opts: ICrudControllerOptions<E>) => {
+    new (repository: DefaultCrudRepository<E, EntityRelationType>): {
+        repository: DefaultCrudRepository<E, EntityRelationType>;
         defaultLimit: number;
         find(filter?: Filter<E>): Promise<(E & EntityRelationType)[]>;
         findById(id: IdType, filter?: FilterExcludingWhere<E>): Promise<E & EntityRelationType>;
@@ -40,7 +41,7 @@ export declare const defineCrudController: <E extends BaseTzEntity>(opts: ICrudC
         count(where?: Where<E>): Promise<Count>;
     };
 } | {
-    new (repository: AbstractTzRepository<E, EntityRelationType>, getCurrentUser?: Getter<IJWTTokenPayload>): {
+    new (repository: DefaultCrudRepository<E, EntityRelationType>, getCurrentUser?: Getter<IJWTTokenPayload>): {
         getCurrentUser?: Getter<IJWTTokenPayload>;
         _getContextUser(): Promise<{
             userId: IdType;
@@ -57,7 +58,7 @@ export declare const defineCrudController: <E extends BaseTzEntity>(opts: ICrudC
         deleteById(id: IdType): Promise<{
             id: IdType;
         }>;
-        repository: AbstractTzRepository<E, EntityRelationType>;
+        repository: DefaultCrudRepository<E, EntityRelationType>;
         defaultLimit: number;
         find(filter?: Filter<E>): Promise<(E & EntityRelationType)[]>;
         findById(id: IdType, filter?: FilterExcludingWhere<E>): Promise<E & EntityRelationType>;

package/dist/base/controllers/crud.controller.js

@@ -26,9 +26,9 @@ const core_1 = require("@loopback/core");
 const repository_1 = require("@loopback/repository");
 const rest_1 = require("@loopback/rest");
 const common_1 = require("../../common");
-const common_2 = require("./common");
-const security_1 = require("@loopback/security");
 const model_utility_1 = require("../../utilities/model.utility");
+const security_1 = require("@loopback/security");
+const common_2 = require("./common");
 // --------------------------------------------------------------------------------------------------------------
 const defineCrudController = (opts) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
@@ -246,7 +246,7 @@ const defineCrudController = (opts) => {
                 'application/json': {
                     schema: (_e = schemaOptions === null || schemaOptions === void 0 ? void 0 : schemaOptions.createRequestBody) !== null && _e !== void 0 ? _e : (0, rest_1.getModelSchemaRef)(entityOptions, {
                         title: `New ${entityOptions.name} payload`,
-                        exclude: ['id', 'createdAt', 'modifiedAt'],
+                        // exclude: ['id', 'createdAt', 'modifiedAt'],
                     }),
                 },
             },

package/dist/base/controllers/relational.controller.d.ts

@@ -2,7 +2,7 @@ import { ControllerClass } from '@loopback/core';
 import { SchemaObject } from '@loopback/rest';
 import { NullableType, TRelationType } from '../../common/types';
 import { Class } from '@loopback/service-proxy';
-import { BaseTzEntity } from './..';
+import { TBaseTzEntity } from '../models';
 import { BaseController } from './common';
 export interface IRelationCrudControllerOptions {
     association: {
@@ -31,9 +31,9 @@ export interface IRelationCrudControllerOptions {
         endPoint?: string;
     };
 }
-export declare const defineRelationViewController: <S extends BaseTzEntity, // Source Entity Type
-T extends BaseTzEntity, // Target Entity Type
-TE extends BaseTzEntity = any>(opts: {
+export declare const defineRelationViewController: <S extends TBaseTzEntity, // Source Entity Type
+T extends TBaseTzEntity, // Target Entity Type
+TE extends TBaseTzEntity = any>(opts: {
     baseClass?: Class<BaseController>;
     entities: {
         source: string;
@@ -47,7 +47,7 @@ TE extends BaseTzEntity = any>(opts: {
     endPoint?: string;
     schema?: SchemaObject;
 }) => ControllerClass;
-export declare const defineAssociateController: <S extends BaseTzEntity, T extends BaseTzEntity, R extends BaseTzEntity | NullableType>(opts: {
+export declare const defineAssociateController: <S extends TBaseTzEntity, T extends TBaseTzEntity, R extends TBaseTzEntity | NullableType>(opts: {
     baseClass: ReturnType<typeof defineRelationViewController>;
     relation: {
         name: string;
@@ -57,4 +57,4 @@ export declare const defineAssociateController: <S extends BaseTzEntity, T exten
     endPoint?: string;
     schema?: SchemaObject;
 }) => ControllerClass;
-export declare const defineRelationCrudController: <S extends BaseTzEntity, T extends BaseTzEntity, R extends BaseTzEntity | NullableType>(controllerOptions: IRelationCrudControllerOptions) => ControllerClass;
+export declare const defineRelationCrudController: <S extends TBaseTzEntity, T extends TBaseTzEntity, R extends TBaseTzEntity | NullableType>(controllerOptions: IRelationCrudControllerOptions) => ControllerClass;

package/dist/base/controllers/relational.controller.js

@@ -31,8 +31,8 @@ const rest_1 = require("@loopback/rest");
 const get_1 = __importDefault(require("lodash/get"));
 const common_1 = require("../../common");
 const utilities_1 = require("../../utilities");
-const common_2 = require("./common");
 const security_1 = require("@loopback/security");
+const common_2 = require("./common");
 // --------------------------------------------------------------------------------------------------------------
 const defineRelationViewController = (opts) => {
     const { baseClass, entities, relation, defaultLimit = common_1.App.DEFAULT_QUERY_LIMIT, endPoint = '', schema, } = opts;

package/dist/base/controllers/service-crud.controller.d.ts

@@ -1,12 +1,12 @@
 import { Getter } from '@loopback/core';
 import { Count, Filter, FilterExcludingWhere, Where } from '@loopback/repository';
-import { SchemaRef, RequestContext } from '@loopback/rest';
+import { RequestContext, SchemaRef } from '@loopback/rest';
 import { CrudRestControllerOptions } from '@loopback/rest-crud';
 import { EntityRelationType, ICrudService, IdType } from '../../common/types';
 import { IJWTTokenPayload } from '../../components/authenticate/common/types';
-import { BaseIdEntity, BaseTzEntity } from './../';
-export interface IServiceCrudControllerOptions<E extends BaseIdEntity> {
-    entity: typeof BaseIdEntity & {
+import { BaseEntity, TBaseTzEntity } from '../models';
+export interface IServiceCrudControllerOptions<E extends BaseEntity> {
+    entity: typeof BaseEntity & {
         prototype: E;
     };
     service: {
@@ -32,7 +32,7 @@ export interface IServiceCrudControllerOptions<E extends BaseIdEntity> {
         doInjectCurrentUser?: boolean;
     };
 }
-export declare const defineServiceCrudController: <E extends BaseTzEntity>(opts: IServiceCrudControllerOptions<E>) => {
+export declare const defineServiceCrudController: <E extends TBaseTzEntity>(opts: IServiceCrudControllerOptions<E>) => {
     new (requestContext: RequestContext, service: ICrudService<E>, getCurrentUser?: Getter<IJWTTokenPayload>): {
         requestContext: RequestContext;
         service: ICrudService<E>;

package/dist/base/controllers/service-crud.controller.js

@@ -17,9 +17,9 @@ const core_1 = require("@loopback/core");
 const repository_1 = require("@loopback/repository");
 const rest_1 = require("@loopback/rest");
 const common_1 = require("../../common");
+const model_utility_1 = require("../../utilities/model.utility");
 const security_1 = require("@loopback/security");
 const common_2 = require("./common");
-const model_utility_1 = require("../../utilities/model.utility");
 // --------------------------------------------------------------------------------------------------------------
 const defineServiceCrudController = (opts) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;

package/dist/base/models/base.model.d.ts

@@ -1,8 +1,8 @@
 import { Entity } from '@loopback/repository';
 export declare class BaseEntity extends Entity {
 }
-export declare class BaseIdEntity extends BaseEntity {
-    id: number;
+export declare class BaseKVEntity<T = any> extends BaseEntity {
+    payload: T;
 }
 export declare class BaseNumberIdEntity extends BaseEntity {
     id: number;
@@ -10,10 +10,10 @@ export declare class BaseNumberIdEntity extends BaseEntity {
 export declare class BaseStringIdEntity extends BaseEntity {
     id: string;
 }
-export declare class BaseKVEntity extends BaseEntity {
-    payload: any;
+export declare class BaseIdEntity extends BaseNumberIdEntity {
 }
-declare const BaseTzEntity_base: {
+export type TBaseIdEntity = BaseNumberIdEntity | BaseStringIdEntity;
+declare const BaseNumberTzEntity_base: {
     new (...args: any[]): {
         createdAt: Date;
         modifiedAt: Date;
@@ -22,10 +22,25 @@ declare const BaseTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseIdEntity;
-export declare class BaseTzEntity extends BaseTzEntity_base {
+} & typeof BaseNumberIdEntity;
+export declare class BaseNumberTzEntity extends BaseNumberTzEntity_base {
+}
+declare const BaseStringTzEntity_base: {
+    new (...args: any[]): {
+        createdAt: Date;
+        modifiedAt: Date;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringIdEntity;
+export declare class BaseStringTzEntity extends BaseStringTzEntity_base {
+}
+export declare class BaseTzEntity extends BaseNumberTzEntity {
 }
-declare const BaseUserAuditTzEntity_base: {
+export type TBaseTzEntity = BaseNumberTzEntity | BaseStringTzEntity;
+declare const BaseNumberUserAuditTzEntity_base: {
     new (...args: any[]): {
         createdBy: import("../..").IdType;
         modifiedBy: import("../..").IdType;
@@ -34,7 +49,7 @@ declare const BaseUserAuditTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
+} & typeof BaseNumberTzEntity;
 /**
  * Basic UserAuditMixed class with createdBy and modifiedBy
  *
@@ -42,9 +57,39 @@ declare const BaseUserAuditTzEntity_base: {
  *
  * In case you need to include User, directly extends {@link UserAuditMixin}
  */
-export declare class BaseUserAuditTzEntity extends BaseUserAuditTzEntity_base {
+export declare class BaseNumberUserAuditTzEntity extends BaseNumberUserAuditTzEntity_base {
+}
+declare const BaseStringUserAuditTzEntity_base: {
+    new (...args: any[]): {
+        createdBy: import("../..").IdType;
+        modifiedBy: import("../..").IdType;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringTzEntity;
+export declare class BaseStringUserAuditTzEntity extends BaseStringUserAuditTzEntity_base {
+}
+export declare class BaseUserAuditTzEntity extends BaseNumberUserAuditTzEntity {
+}
+export type TBaseUserAuditTzEntity = BaseNumberUserAuditTzEntity | BaseStringUserAuditTzEntity;
+declare const BaseNumberDataTypeTzEntity_base: {
+    new (...args: any[]): {
+        tValue?: string;
+        nValue?: number;
+        jValue?: any;
+        bValue?: Array<number>;
+        dataType?: string;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberDataTypeTzEntity extends BaseNumberDataTypeTzEntity_base {
 }
-declare const BaseDataTypeTzEntity_base: {
+declare const BaseStringDataTypeTzEntity_base: {
     new (...args: any[]): {
         tValue?: string;
         nValue?: number;
@@ -56,10 +101,13 @@ declare const BaseDataTypeTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseDataTypeTzEntity extends BaseDataTypeTzEntity_base {
+} & typeof BaseStringTzEntity;
+export declare class BaseStringDataTypeTzEntity extends BaseStringDataTypeTzEntity_base {
 }
-declare const BaseTextSearchTzEntity_base: {
+export declare class BaseDataTypeTzEntity extends BaseNumberDataTypeTzEntity {
+}
+export type TBaseDataTypeTzEntity = BaseNumberDataTypeTzEntity | BaseStringDataTypeTzEntity;
+declare const BaseNumberTextSearchTzEntity_base: {
     new (...args: any[]): {
         textSearch?: string;
         getId: () => any;
@@ -67,10 +115,24 @@ declare const BaseTextSearchTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseTextSearchTzEntity extends BaseTextSearchTzEntity_base {
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberTextSearchTzEntity extends BaseNumberTextSearchTzEntity_base {
 }
-declare const BaseObjectSearchTzEntity_base: {
+declare const BaseStringTextSearchTzEntity_base: {
+    new (...args: any[]): {
+        textSearch?: string;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringTzEntity;
+export declare class BaseStringTextSearchTzEntity extends BaseStringTextSearchTzEntity_base {
+}
+export declare class BaseTextSearchTzEntity extends BaseNumberTextSearchTzEntity {
+}
+export type TBaseTextSearchTzEntity = BaseNumberTextSearchTzEntity | BaseStringTextSearchTzEntity;
+declare const BaseNumberObjectSearchTzEntity_base: {
     new (...args: any[]): {
         objectSearch?: import("../..").AnyObject | undefined;
         getId: () => any;
@@ -78,10 +140,24 @@ declare const BaseObjectSearchTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseObjectSearchTzEntity extends BaseObjectSearchTzEntity_base {
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberObjectSearchTzEntity extends BaseNumberObjectSearchTzEntity_base {
 }
-declare const BaseSearchableTzEntity_base: {
+declare const BaseStringObjectSearchTzEntity_base: {
+    new (...args: any[]): {
+        objectSearch?: import("../..").AnyObject | undefined;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringTzEntity;
+export declare class BaseStringObjectSearchTzEntity extends BaseStringObjectSearchTzEntity_base {
+}
+export declare class BaseObjectSearchTzEntity extends BaseNumberObjectSearchTzEntity {
+}
+export type TBaseObjectSearchTzEntity = BaseNumberObjectSearchTzEntity | BaseStringObjectSearchTzEntity;
+declare const BaseNumberSearchableTzEntity_base: {
     new (...args: any[]): {
         objectSearch?: import("../..").AnyObject | undefined;
         getId: () => any;
@@ -97,10 +173,32 @@ declare const BaseSearchableTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseSearchableTzEntity extends BaseSearchableTzEntity_base {
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberSearchableTzEntity extends BaseNumberSearchableTzEntity_base {
 }
-declare const BaseSoftDeleteTzEntity_base: {
+declare const BaseStringSearchableTzEntity_base: {
+    new (...args: any[]): {
+        objectSearch?: import("../..").AnyObject | undefined;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & {
+    new (...args: any[]): {
+        textSearch?: string;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringTzEntity;
+export declare class BaseStringSearchableTzEntity extends BaseStringSearchableTzEntity_base {
+}
+export declare class BaseSearchableTzEntity extends BaseNumberSearchableTzEntity {
+}
+export type TBaseSearchableTzEntity = BaseNumberSearchableTzEntity | BaseStringSearchableTzEntity;
+declare const BaseNumberSoftDeleteTzEntity_base: {
     new (...args: any[]): {
         isDeleted?: boolean;
         getId: () => any;
@@ -108,21 +206,48 @@ declare const BaseSoftDeleteTzEntity_base: {
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseSoftDeleteTzEntity extends BaseSoftDeleteTzEntity_base {
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberSoftDeleteTzEntity extends BaseNumberSoftDeleteTzEntity_base {
 }
-declare const BaseDuplicatableTzEntity_base: {
+declare const BaseStringSoftDeleteTzEntity_base: {
+    new (...args: any[]): {
+        isDeleted?: boolean;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseStringTzEntity;
+export declare class BaseStringSoftDeleteTzEntity extends BaseStringSoftDeleteTzEntity_base {
+}
+export declare class BaseSoftDeleteTzEntity extends BaseNumberSoftDeleteTzEntity {
+}
+export type TBaseSoftDeleteTzEntity = BaseNumberSoftDeleteTzEntity | BaseStringSoftDeleteTzEntity;
+declare const BaseNumberDuplicatableTzEntity_base: {
+    new (...args: any[]): {
+        sourceId?: import("../..").IdType;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & typeof BaseNumberTzEntity;
+export declare class BaseNumberDuplicatableTzEntity extends BaseNumberDuplicatableTzEntity_base {
+}
+declare const BaseStringDuplicatableTzEntity_base: {
     new (...args: any[]): {
         sourceId?: import("../..").IdType;
-        id: number;
         getId: () => any;
         getIdObject: () => Object;
         toJSON: () => Object;
         toObject: (options?: import("@loopback/repository").Options) => Object;
     };
-} & typeof BaseTzEntity;
-export declare class BaseDuplicatableTzEntity extends BaseDuplicatableTzEntity_base {
+} & typeof BaseNumberTzEntity;
+export declare class BaseStringDuplicatableTzEntity extends BaseStringDuplicatableTzEntity_base {
+}
+export declare class BaseDuplicatableTzEntity extends BaseNumberDuplicatableTzEntity {
 }
+export type TBaseDuplicatableTzEntity = BaseNumberDuplicatableTzEntity | BaseStringDuplicatableTzEntity;
 export declare class BaseBigIdEntity extends BaseEntity {
     id: number;
 }

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

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 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;
+exports.BaseVectorEntity = exports.BaseBigIdTzEntity = exports.BaseBigIdEntity = exports.BaseDuplicatableTzEntity = exports.BaseStringDuplicatableTzEntity = exports.BaseNumberDuplicatableTzEntity = exports.BaseSoftDeleteTzEntity = exports.BaseStringSoftDeleteTzEntity = exports.BaseNumberSoftDeleteTzEntity = exports.BaseSearchableTzEntity = exports.BaseStringSearchableTzEntity = exports.BaseNumberSearchableTzEntity = exports.BaseObjectSearchTzEntity = exports.BaseStringObjectSearchTzEntity = exports.BaseNumberObjectSearchTzEntity = exports.BaseTextSearchTzEntity = exports.BaseStringTextSearchTzEntity = exports.BaseNumberTextSearchTzEntity = exports.BaseDataTypeTzEntity = exports.BaseStringDataTypeTzEntity = exports.BaseNumberDataTypeTzEntity = exports.BaseUserAuditTzEntity = exports.BaseStringUserAuditTzEntity = exports.BaseNumberUserAuditTzEntity = exports.BaseTzEntity = exports.BaseStringTzEntity = exports.BaseNumberTzEntity = exports.BaseIdEntity = exports.BaseStringIdEntity = exports.BaseNumberIdEntity = exports.BaseKVEntity = exports.BaseEntity = void 0;
 const mixins_1 = require("../../mixins");
 const repository_1 = require("@loopback/repository");
 // ---------------------------------------------------------------------
@@ -17,13 +17,13 @@ class BaseEntity extends repository_1.Entity {
 }
 exports.BaseEntity = BaseEntity;
 // ---------------------------------------------------------------------
-class BaseIdEntity extends BaseEntity {
+class BaseKVEntity extends BaseEntity {
 }
-exports.BaseIdEntity = BaseIdEntity;
+exports.BaseKVEntity = BaseKVEntity;
 __decorate([
-    (0, repository_1.property)({ type: 'number', id: true, generated: true }),
-    __metadata("design:type", Number)
-], BaseIdEntity.prototype, "id", void 0);
+    (0, repository_1.property)({ type: 'object' }),
+    __metadata("design:type", Object)
+], BaseKVEntity.prototype, "payload", void 0);
 // ---------------------------------------------------------------------
 class BaseNumberIdEntity extends BaseEntity {
 }
@@ -32,7 +32,6 @@ __decorate([
     (0, repository_1.property)({ type: 'number', id: true, generated: true }),
     __metadata("design:type", Number)
 ], BaseNumberIdEntity.prototype, "id", void 0);
-// ---------------------------------------------------------------------
 class BaseStringIdEntity extends BaseEntity {
 }
 exports.BaseStringIdEntity = BaseStringIdEntity;
@@ -40,16 +39,17 @@ __decorate([
     (0, repository_1.property)({ type: 'string', id: true }),
     __metadata("design:type", String)
 ], BaseStringIdEntity.prototype, "id", void 0);
-// ---------------------------------------------------------------------
-class BaseKVEntity extends BaseEntity {
+class BaseIdEntity extends BaseNumberIdEntity {
 }
-exports.BaseKVEntity = BaseKVEntity;
-__decorate([
-    (0, repository_1.property)({ type: 'object' }),
-    __metadata("design:type", Object)
-], BaseKVEntity.prototype, "payload", void 0);
+exports.BaseIdEntity = BaseIdEntity;
 // ---------------------------------------------------------------------
-class BaseTzEntity extends (0, mixins_1.TzMixin)(BaseIdEntity) {
+class BaseNumberTzEntity extends (0, mixins_1.TzMixin)(BaseNumberIdEntity) {
+}
+exports.BaseNumberTzEntity = BaseNumberTzEntity;
+class BaseStringTzEntity extends (0, mixins_1.TzMixin)(BaseStringIdEntity) {
+}
+exports.BaseStringTzEntity = BaseStringTzEntity;
+class BaseTzEntity extends BaseNumberTzEntity {
 }
 exports.BaseTzEntity = BaseTzEntity;
 // ---------------------------------------------------------------------
@@ -60,31 +60,73 @@ exports.BaseTzEntity = BaseTzEntity;
  *
  * In case you need to include User, directly extends {@link UserAuditMixin}
  */
-class BaseUserAuditTzEntity extends (0, mixins_1.UserAuditMixin)(BaseTzEntity) {
+class BaseNumberUserAuditTzEntity extends (0, mixins_1.UserAuditMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberUserAuditTzEntity = BaseNumberUserAuditTzEntity;
+class BaseStringUserAuditTzEntity extends (0, mixins_1.UserAuditMixin)(BaseStringTzEntity) {
+}
+exports.BaseStringUserAuditTzEntity = BaseStringUserAuditTzEntity;
+class BaseUserAuditTzEntity extends BaseNumberUserAuditTzEntity {
 }
 exports.BaseUserAuditTzEntity = BaseUserAuditTzEntity;
 // ---------------------------------------------------------------------
-class BaseDataTypeTzEntity extends (0, mixins_1.DataTypeMixin)(BaseTzEntity) {
+class BaseNumberDataTypeTzEntity extends (0, mixins_1.DataTypeMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberDataTypeTzEntity = BaseNumberDataTypeTzEntity;
+class BaseStringDataTypeTzEntity extends (0, mixins_1.DataTypeMixin)(BaseStringTzEntity) {
+}
+exports.BaseStringDataTypeTzEntity = BaseStringDataTypeTzEntity;
+class BaseDataTypeTzEntity extends BaseNumberDataTypeTzEntity {
 }
 exports.BaseDataTypeTzEntity = BaseDataTypeTzEntity;
 // ---------------------------------------------------------------------
-class BaseTextSearchTzEntity extends (0, mixins_1.TextSearchMixin)(BaseTzEntity) {
+class BaseNumberTextSearchTzEntity extends (0, mixins_1.TextSearchMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberTextSearchTzEntity = BaseNumberTextSearchTzEntity;
+class BaseStringTextSearchTzEntity extends (0, mixins_1.TextSearchMixin)(BaseStringTzEntity) {
+}
+exports.BaseStringTextSearchTzEntity = BaseStringTextSearchTzEntity;
+class BaseTextSearchTzEntity extends BaseNumberTextSearchTzEntity {
 }
 exports.BaseTextSearchTzEntity = BaseTextSearchTzEntity;
 // ---------------------------------------------------------------------
-class BaseObjectSearchTzEntity extends (0, mixins_1.ObjectSearchMixin)(BaseTzEntity) {
+class BaseNumberObjectSearchTzEntity extends (0, mixins_1.ObjectSearchMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberObjectSearchTzEntity = BaseNumberObjectSearchTzEntity;
+class BaseStringObjectSearchTzEntity extends (0, mixins_1.ObjectSearchMixin)(BaseStringTzEntity) {
+}
+exports.BaseStringObjectSearchTzEntity = BaseStringObjectSearchTzEntity;
+class BaseObjectSearchTzEntity extends BaseNumberObjectSearchTzEntity {
 }
 exports.BaseObjectSearchTzEntity = BaseObjectSearchTzEntity;
 // ---------------------------------------------------------------------
-class BaseSearchableTzEntity extends (0, mixins_1.ObjectSearchMixin)((0, mixins_1.TextSearchMixin)(BaseTzEntity)) {
+class BaseNumberSearchableTzEntity extends (0, mixins_1.ObjectSearchMixin)((0, mixins_1.TextSearchMixin)(BaseNumberTzEntity)) {
+}
+exports.BaseNumberSearchableTzEntity = BaseNumberSearchableTzEntity;
+class BaseStringSearchableTzEntity extends (0, mixins_1.ObjectSearchMixin)((0, mixins_1.TextSearchMixin)(BaseStringTzEntity)) {
+}
+exports.BaseStringSearchableTzEntity = BaseStringSearchableTzEntity;
+class BaseSearchableTzEntity extends BaseNumberSearchableTzEntity {
 }
 exports.BaseSearchableTzEntity = BaseSearchableTzEntity;
 // ---------------------------------------------------------------------
-class BaseSoftDeleteTzEntity extends (0, mixins_1.SoftDeleteModelMixin)(BaseTzEntity) {
+class BaseNumberSoftDeleteTzEntity extends (0, mixins_1.SoftDeleteModelMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberSoftDeleteTzEntity = BaseNumberSoftDeleteTzEntity;
+class BaseStringSoftDeleteTzEntity extends (0, mixins_1.SoftDeleteModelMixin)(BaseStringTzEntity) {
+}
+exports.BaseStringSoftDeleteTzEntity = BaseStringSoftDeleteTzEntity;
+class BaseSoftDeleteTzEntity extends BaseNumberSoftDeleteTzEntity {
 }
 exports.BaseSoftDeleteTzEntity = BaseSoftDeleteTzEntity;
 // ---------------------------------------------------------------------
-class BaseDuplicatableTzEntity extends (0, mixins_1.DuplicatableMixin)(BaseTzEntity) {
+class BaseNumberDuplicatableTzEntity extends (0, mixins_1.DuplicatableMixin)(BaseNumberTzEntity) {
+}
+exports.BaseNumberDuplicatableTzEntity = BaseNumberDuplicatableTzEntity;
+class BaseStringDuplicatableTzEntity extends (0, mixins_1.DuplicatableMixin)(BaseNumberTzEntity) {
+}
+exports.BaseStringDuplicatableTzEntity = BaseStringDuplicatableTzEntity;
+class BaseDuplicatableTzEntity extends BaseNumberDuplicatableTzEntity {
 }
 exports.BaseDuplicatableTzEntity = BaseDuplicatableTzEntity;
 // ---------------------------------------------------------------------

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

@@ -1,13 +1,13 @@
 import { EntityClassType, EntityRelationType, IdType, ITzRepository, TDBAction } from '../../common/types';
 import { ApplicationLogger } from '../../helpers';
 import { DefaultCrudRepository as _DefaultCrudRepository, AnyObject, WhereBuilder as BaseWhereBuilder, Command, Count, DataObject, DefaultKeyValueRepository, EntityCrudRepository, Getter, HasManyRepositoryFactory, IsolationLevel, juggler, NamedParameters, PositionalParameters, Transaction, TransactionalEntityRepository, Where } from '@loopback/repository';
-import { BaseEntity, BaseKVEntity, BaseTzEntity } from './../models';
+import { BaseEntity, BaseKVEntity, TBaseTzEntity } from './../models';
 export declare class WhereBuilder<E extends object = AnyObject> extends BaseWhereBuilder {
     constructor(opts?: Where<E>);
     newInstance(opts?: Where<E>): WhereBuilder<E>;
     clone(): WhereBuilder;
 }
-export declare class DefaultCrudRepository<E extends BaseEntity, ID, Relations extends object = {}> extends _DefaultCrudRepository<E, ID, Relations> {
+export declare abstract class DefaultCrudRepository<E extends BaseEntity, ID, Relations extends object = {}> extends _DefaultCrudRepository<E, ID, Relations> {
     /**
      * @experimental
      */
@@ -16,8 +16,12 @@ export declare class DefaultCrudRepository<E extends BaseEntity, ID, Relations e
         principalType: string;
         targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetId>>;
     }): HasManyRepositoryFactory<Target, ForeignKeyType>;
+    abstract existsWith(where?: Where<E>, options?: TDBAction): Promise<boolean>;
+    abstract createWithReturn(data: DataObject<E>, options?: TDBAction): Promise<E>;
+    abstract updateWithReturn(id: IdType, data: DataObject<E>, options?: TDBAction): Promise<E>;
+    abstract upsertWith(data: DataObject<E>, where: Where<E>, options?: TDBAction): Promise<E | null>;
 }
-export declare abstract class AbstractTzRepository<E extends BaseTzEntity, R extends EntityRelationType = EntityRelationType> extends DefaultCrudRepository<E, IdType, R> implements ITzRepository<E>, TransactionalEntityRepository<E, IdType, R> {
+export declare abstract class AbstractTzRepository<E extends TBaseTzEntity, R extends EntityRelationType = EntityRelationType> extends DefaultCrudRepository<E, IdType, R> implements ITzRepository<E>, TransactionalEntityRepository<E, IdType, R> {
     protected logger: ApplicationLogger;
     constructor(entityClass: EntityClassType<E>, dataSource: juggler.DataSource, scope?: string);
     beginTransaction(options?: IsolationLevel | AnyObject): Promise<Transaction>;
@@ -37,10 +41,6 @@ export declare abstract class AbstractTzRepository<E extends BaseTzEntity, R ext
         newInstance: boolean;
         authorId: IdType;
     }): DataObject<E>;
-    abstract existsWith(where?: Where<E>, options?: TDBAction): Promise<boolean>;
-    abstract createWithReturn(data: DataObject<E>, options?: TDBAction): Promise<E>;
-    abstract updateWithReturn(id: IdType, data: DataObject<E>, options?: TDBAction): Promise<E>;
-    abstract upsertWith(data: DataObject<E>, where: Where<E>, options?: TDBAction): Promise<E | null>;
 }
 export declare abstract class AbstractKVRepository<E extends BaseKVEntity> extends DefaultKeyValueRepository<E> {
     constructor(entityClass: EntityClassType<E>, dataSource: juggler.DataSource);
@@ -61,4 +61,7 @@ export declare abstract class ViewRepository<E extends BaseEntity, R extends Ent
     replaceById(_id: IdType, _data: DataObject<E>, _options?: TDBAction): Promise<void>;
     deleteAll(_where?: Where<E>, _options?: TDBAction): Promise<Count>;
     deleteById(_id: IdType, _options?: TDBAction): Promise<void>;
+    createWithReturn(_data: DataObject<E>, _options?: TDBAction): Promise<E>;
+    updateWithReturn(_id: IdType, _data: DataObject<E>, _options?: TDBAction): Promise<E>;
+    upsertWith(_data: DataObject<E>, _where: Where<E>, _options?: TDBAction): Promise<E | null>;
 }

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

@@ -173,5 +173,23 @@ class ViewRepository extends DefaultCrudRepository {
             message: 'Cannot manipulate entity with view repository!',
         });
     }
+    createWithReturn(_data, _options) {
+        throw (0, utilities_1.getError)({
+            statusCode: 500,
+            message: 'Cannot manipulate entity with view repository!',
+        });
+    }
+    updateWithReturn(_id, _data, _options) {
+        throw (0, utilities_1.getError)({
+            statusCode: 500,
+            message: 'Cannot manipulate entity with view repository!',
+        });
+    }
+    upsertWith(_data, _where, _options) {
+        throw (0, utilities_1.getError)({
+            statusCode: 500,
+            message: 'Cannot manipulate entity with view repository!',
+        });
+    }
 }
 exports.ViewRepository = ViewRepository;

package/dist/base/repositories/searchable-tz-crud.repository.d.ts

@@ -1,6 +1,6 @@
 import { AnyObject, EntityClassType, EntityRelationType, IdType, TDBAction, TRelationType } from '../../common/types';
 import { DataObject, Getter, Inclusion, juggler, Where } from '@loopback/repository';
-import { BaseObjectSearchTzEntity, BaseSearchableTzEntity, BaseTextSearchTzEntity, BaseTzEntity } from './../models';
+import { BaseObjectSearchTzEntity, BaseSearchableTzEntity, BaseTextSearchTzEntity, TBaseTzEntity } from './../models';
 import { TzCrudRepository } from './tz-crud.repository';
 export declare abstract class SearchableTzCrudRepository<E extends BaseTextSearchTzEntity | BaseObjectSearchTzEntity | BaseSearchableTzEntity, R extends EntityRelationType = EntityRelationType> extends TzCrudRepository<E, R> {
     protected readonly searchableInclusions: Inclusion[];
@@ -17,14 +17,14 @@ export declare abstract class SearchableTzCrudRepository<E extends BaseTextSearc
         data?: DataObject<E>;
         entity: E & R;
     }): object;
-    abstract onInclusionChanged<RM extends BaseTzEntity>(opts: {
+    abstract onInclusionChanged<RM extends TBaseTzEntity>(opts: {
         relation: string;
         relationRepository: TzCrudRepository<RM>;
         entities: RM[];
         options?: AnyObject;
     }): Promise<void>;
-    protected registerOnInclusionChanged<RM extends BaseTzEntity>(relation: string, relationRepositoryGetter: Getter<TzCrudRepository<RM>>): Promise<void>;
-    protected handleInclusionChanged<RM extends BaseTzEntity>(opts: {
+    protected registerOnInclusionChanged<RM extends TBaseTzEntity>(relation: string, relationRepositoryGetter: Getter<TzCrudRepository<RM>>): Promise<void>;
+    protected handleInclusionChanged<RM extends TBaseTzEntity>(opts: {
         relationName: string;
         relationType: TRelationType;
         entities: RM[];

package/dist/base/repositories/tz-crud.repository.d.ts

@@ -1,8 +1,8 @@
 import { EntityClassType, EntityRelationType, IdType, TDBAction } from '../../common/types';
 import { Count, DataObject, juggler, Where } from '@loopback/repository';
-import { BaseTzEntity } from './../models';
 import { AbstractTzRepository } from './base.repository';
-export declare abstract class TzCrudRepository<E extends BaseTzEntity, R extends EntityRelationType = EntityRelationType> extends AbstractTzRepository<E, R> {
+import { TBaseTzEntity } from '../models';
+export declare abstract class TzCrudRepository<E extends TBaseTzEntity, R extends EntityRelationType = EntityRelationType> extends AbstractTzRepository<E, R> {
     constructor(entityClass: EntityClassType<E>, dataSource: juggler.DataSource, scope?: string);
     existsWith(where?: Where<E>, options?: TDBAction): Promise<boolean>;
     create(data: DataObject<E>, options?: TDBAction & {

package/dist/base/services/base-crud.service.d.ts

@@ -1,9 +1,9 @@
 import { EntityRelationType, ICrudMethodOptions, ICrudService, IdType } from '../../common';
 import { Count, Filter, Where } from '@loopback/repository';
+import { TBaseTzEntity } from '../models';
 import { AbstractTzRepository } from '../repositories';
-import { BaseTzEntity } from './../models';
 import { BaseService } from './base.service';
-export declare abstract class BaseCrudService<E extends BaseTzEntity> extends BaseService implements ICrudService<E> {
+export declare abstract class BaseCrudService<E extends TBaseTzEntity> extends BaseService implements ICrudService<E> {
     repository: AbstractTzRepository<E, EntityRelationType>;
     constructor(opts: {
         scope: string;

package/dist/common/types.d.ts

@@ -1,5 +1,5 @@
-import { AbstractTzRepository } from '../base';
-import { BaseEntity, BaseIdEntity, BaseTzEntity } from '../base/models';
+import { BaseEntity, TBaseIdEntity, TBaseTzEntity } from '../base/models';
+import { AbstractTzRepository } from '../base/repositories';
 import { Binding, BindingFromClassOptions, BindingKey, Constructor, ControllerClass } from '@loopback/core';
 import { Count, DataObject, Entity, Filter, JugglerDataSource, Options, Repository, Transaction, Where } from '@loopback/repository';
 import { RequestContext, SequenceHandler } from '@loopback/rest';
@@ -115,7 +115,7 @@ export interface IRepository {
 export type TDBAction = Options & {
     transaction?: Transaction;
 };
-export interface IPersistableRepository<E extends BaseIdEntity> extends IRepository {
+export interface IPersistableRepository<E extends TBaseIdEntity> extends IRepository {
     findOne(filter?: Filter<E>, options?: TDBAction): Promise<E | null>;
     existsWith(where?: Where<any>, options?: TDBAction): Promise<boolean>;
     create(data: DataObject<E>, options?: TDBAction): Promise<E>;
@@ -127,7 +127,7 @@ export interface IPersistableRepository<E extends BaseIdEntity> extends IReposit
     upsertWith(data: DataObject<E>, where: Where<any>, options?: TDBAction): Promise<E | null>;
     replaceById(id: IdType, data: DataObject<E>, options?: TDBAction): Promise<void>;
 }
-export interface ITzRepository<E extends BaseTzEntity> extends IPersistableRepository<E> {
+export interface ITzRepository<E extends TBaseTzEntity> extends IPersistableRepository<E> {
     mixTimestamp(entity: DataObject<E>, options?: {
         newInstance: boolean;
     }): DataObject<E>;
@@ -151,7 +151,7 @@ export interface ICrudMethodOptions {
     requestContext: RequestContext;
     [extra: symbol | string]: any;
 }
-export interface ICrudService<E extends BaseTzEntity> extends IService {
+export interface ICrudService<E extends TBaseTzEntity> extends IService {
     repository: AbstractTzRepository<E, EntityRelationType>;
     find(filter: Filter<E>, options: ICrudMethodOptions): Promise<Array<E & EntityRelationType>>;
     findById(id: IdType, filter: Filter<E>, options: ICrudMethodOptions): Promise<E & EntityRelationType>;

package/dist/components/authenticate/models/oauth2-client.model.d.ts

@@ -1,6 +1,6 @@
-import { BaseTzEntity } from '../../../base/models';
+import { BaseNumberTzEntity } from '../../../base';
 import { NumberIdType } from '../../../common';
-export declare class OAuth2Client extends BaseTzEntity {
+export declare class OAuth2Client extends BaseNumberTzEntity {
     identifier: string;
     clientId: string;
     name: string;

package/dist/components/authenticate/models/oauth2-client.model.js

@@ -10,9 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAuth2Client = void 0;
-const models_1 = require("../../../base/models");
+const base_1 = require("../../../base");
 const repository_1 = require("@loopback/repository");
-let OAuth2Client = class OAuth2Client extends models_1.BaseTzEntity {
+let OAuth2Client = class OAuth2Client extends base_1.BaseNumberTzEntity {
     constructor(data) {
         super(data);
     }

package/dist/components/authenticate/models/oauth2-scope.model.d.ts

@@ -1,5 +1,5 @@
-import { BaseTzEntity } from '../../../base/models';
-export declare class OAuth2Scope extends BaseTzEntity {
+import { BaseNumberTzEntity } from '../../../base';
+export declare class OAuth2Scope extends BaseNumberTzEntity {
     identifier: string;
     name: string;
     description: string;

package/dist/components/authenticate/models/oauth2-scope.model.js

@@ -10,9 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAuth2Scope = void 0;
-const models_1 = require("../../../base/models");
+const base_1 = require("../../../base");
 const repository_1 = require("@loopback/repository");
-let OAuth2Scope = class OAuth2Scope extends models_1.BaseTzEntity {
+let OAuth2Scope = class OAuth2Scope extends base_1.BaseNumberTzEntity {
     constructor(data) {
         super(data);
     }

package/dist/components/authenticate/models/oauth2-token.model.d.ts

@@ -1,6 +1,6 @@
-import { BaseTzEntity } from '../../../base/models';
+import { BaseNumberTzEntity } from '../../../base';
 import { AnyObject, IdType } from '../../../common';
-export declare class OAuth2Token extends BaseTzEntity {
+export declare class OAuth2Token extends BaseNumberTzEntity {
     token: string;
     type: string;
     status: string;

package/dist/components/authenticate/models/oauth2-token.model.js

@@ -10,11 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAuth2Token = void 0;
-const models_1 = require("../../../base/models");
+const base_1 = require("../../../base");
 const common_1 = require("../../../common");
 const repository_1 = require("@loopback/repository");
 const oauth2_client_model_1 = require("./oauth2-client.model");
-let OAuth2Token = class OAuth2Token extends models_1.BaseTzEntity {
+let OAuth2Token = class OAuth2Token extends base_1.BaseNumberTzEntity {
     constructor(data) {
         super(data);
     }

package/dist/components/authenticate/oauth2-handlers/base.d.ts

@@ -1,8 +1,8 @@
-import { BaseTzEntity } from '../../../base/models';
 import { AnyObject, TInjectionGetter } from '../../../common';
 import { ApplicationLogger } from '../../../helpers';
 import { BaseModel, Client, Falsey, RequestAuthenticationModel, Token, User } from '@node-oauth/oauth2-server';
 import { OAuth2Client, OAuth2Token } from '../models';
+import { TBaseTzEntity } from '../../../base/models';
 export interface IOAuth2AuthenticationHandler extends BaseModel, RequestAuthenticationModel {
 }
 export declare abstract class AbstractOAuth2AuthenticationHandler implements IOAuth2AuthenticationHandler {
@@ -30,7 +30,7 @@ export declare abstract class AbstractOAuth2AuthenticationHandler implements IOA
     }): Promise<{
         token: OAuth2Token;
         client: OAuth2Client;
-        user: BaseTzEntity;
+        user: TBaseTzEntity;
     }>;
     getAccessToken(accessToken: string): Promise<Token | Falsey>;
     verifyScope(token: Token, scopes: string[]): Promise<boolean>;

package/dist/components/authorize/models/defs.js

@@ -10,13 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineUserRole = exports.definePermissionMapping = exports.definePermission = exports.defineRole = exports.defineUser = void 0;
-const models_1 = require("../../../base/models");
+const base_1 = require("../../../base");
 const common_1 = require("../../../common");
 const mixins_1 = require("../../../mixins");
 const repository_1 = require("@loopback/repository");
 // -----------------------------------------------------------------------
 const defineUser = () => {
-    class User extends models_1.BaseTzEntity {
+    class User extends base_1.BaseNumberTzEntity {
         constructor(data) {
             super(data);
         }
@@ -83,7 +83,7 @@ const defineUser = () => {
 exports.defineUser = defineUser;
 // -----------------------------------------------------------------------
 const defineRole = () => {
-    class Role extends models_1.BaseTzEntity {
+    class Role extends base_1.BaseNumberTzEntity {
         constructor(data) {
             super(data);
         }
@@ -126,7 +126,7 @@ const defineRole = () => {
 exports.defineRole = defineRole;
 // -----------------------------------------------------------------------
 const definePermission = () => {
-    class Permission extends models_1.BaseTzEntity {
+    class Permission extends base_1.BaseNumberTzEntity {
         constructor(data) {
             super(data);
         }
@@ -190,7 +190,7 @@ const definePermission = () => {
 exports.definePermission = definePermission;
 // -----------------------------------------------------------------------
 const definePermissionMapping = () => {
-    class PermissionMapping extends models_1.BaseTzEntity {
+    class PermissionMapping extends base_1.BaseNumberTzEntity {
         constructor(data) {
             super(data);
         }
@@ -225,7 +225,7 @@ const definePermissionMapping = () => {
 exports.definePermissionMapping = definePermissionMapping;
 // -----------------------------------------------------------------------
 const defineUserRole = () => {
-    class UserRole extends (0, mixins_1.PrincipalMixin)(models_1.BaseTzEntity, 'Role', 'number') {
+    class UserRole extends (0, mixins_1.PrincipalMixin)(base_1.BaseNumberTzEntity, 'Role', 'number') {
         constructor(data) {
             super(data);
         }

package/dist/components/authorize/repositories/authorize.repository.d.ts

@@ -1,11 +1,11 @@
 import { BaseDataSource } from '../../../base/datasources';
-import { BaseTzEntity } from '../../../base/models';
+import { TBaseTzEntity } from '../../../base/models';
 import { TzCrudRepository, ViewRepository } from '../../../base/repositories';
 import { EntityClassType, IdType } from '../../../common';
 import { Getter } from '@loopback/core';
 import { HasManyThroughRepositoryFactory } from '@loopback/repository';
 import { Permission, PermissionMapping, Role, UserRole, ViewAuthorizePolicy } from '../models';
-export declare abstract class AbstractAuthorizeRepository<T extends BaseTzEntity> extends TzCrudRepository<T> {
+export declare abstract class AbstractAuthorizeRepository<T extends TBaseTzEntity> extends TzCrudRepository<T> {
     constructor(entityClass: EntityClassType<T>, dataSource: BaseDataSource);
     abstract bindingRelations(): void;
 }

package/dist/components/migration/models/migration.model.d.ts

@@ -1,5 +1,5 @@
-import { BaseTzEntity } from '../../../base/models';
-export declare class Migration extends BaseTzEntity {
+import { BaseNumberTzEntity } from '../../../base';
+export declare class Migration extends BaseNumberTzEntity {
     name: string;
     status: string;
     constructor(data?: Partial<Migration>);

package/dist/components/migration/models/migration.model.js

@@ -10,10 +10,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Migration = void 0;
-const models_1 = require("../../../base/models");
+const base_1 = require("../../../base");
 const common_1 = require("../../../common");
 const repository_1 = require("@loopback/repository");
-let Migration = class Migration extends models_1.BaseTzEntity {
+let Migration = class Migration extends base_1.BaseNumberTzEntity {
     constructor(data) {
         super(data);
     }

package/dist/interceptors/content-range.interceptor.d.ts

@@ -1,4 +1,4 @@
-import { BaseIdEntity } from '../base/models';
+import { TBaseIdEntity } from '../base';
 import { IController } from '../common';
 import { Interceptor, InvocationContext, InvocationResult, Provider, ValueOrPromise } from '@loopback/core';
 import { Response } from '@loopback/rest';
@@ -12,15 +12,15 @@ export declare class ContentRangeInterceptor implements Provider<Interceptor> {
     }): 'single-entity' | 'relation-entity' | undefined;
     handleSingleEntity(opts: {
         context: InvocationContext;
-        result: Array<BaseIdEntity>;
+        result: Array<TBaseIdEntity>;
     }): Promise<void>;
     handleRelationalEntity(opts: {
         context: InvocationContext;
-        result: Array<BaseIdEntity>;
+        result: Array<TBaseIdEntity>;
     }): Promise<never[] | undefined>;
     enrichResponseContentRange(opts: {
         context: InvocationContext;
-        result: Array<BaseIdEntity>;
+        result: Array<TBaseIdEntity>;
     }): Promise<void>;
     intercept(context: InvocationContext, next: () => ValueOrPromise<InvocationResult>): Promise<any>;
 }

package/dist/mixins/duplicatable.mixin.d.ts

@@ -1,10 +1,9 @@
-import { BaseIdEntity } from '../base/models/base.model';
+import { BaseEntity } from '../base/models';
 import { IdType } from '../common';
 import { MixinTarget } from '@loopback/core';
-export declare const DuplicatableMixin: <E extends MixinTarget<BaseIdEntity>>(superClass: E) => {
+export declare const DuplicatableMixin: <E extends MixinTarget<BaseEntity>>(superClass: E) => {
     new (...args: any[]): {
         sourceId?: IdType;
-        id: number;
         getId: () => any;
         getIdObject: () => Object;
         toJSON: () => Object;

package/dist/mixins/duplicatable.mixin.js

@@ -10,11 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuplicatableMixin = void 0;
-const base_model_1 = require("../base/models/base.model");
+const models_1 = require("../base/models");
 const model_utility_1 = require("../utilities/model.utility");
 const repository_1 = require("@loopback/repository");
 const DuplicatableMixin = (superClass) => {
-    const sourceIdType = (0, model_utility_1.getIdType)(base_model_1.BaseIdEntity);
+    const sourceIdType = (0, model_utility_1.getIdType)(models_1.BaseNumberIdEntity);
     let Mixed = class Mixed extends superClass {
     };
     __decorate([

package/dist/mixins/id.mixin.d.ts

@@ -0,0 +1,39 @@
+import { MixinTarget } from '@loopback/core';
+import { Entity } from '@loopback/repository';
+export declare const NumberIdMixin: <E extends MixinTarget<Entity>>(superClass: E) => {
+    new (...args: any[]): {
+        id: number;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & E;
+export declare const StringIdMixin: <E extends MixinTarget<Entity>>(superClass: E) => {
+    new (...args: any[]): {
+        id?: string;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & E;
+export declare const IdMixin: <E extends MixinTarget<Entity>>(superClass: E, opts: {
+    idType: "string" | "number";
+}) => ({
+    new (...args: any[]): {
+        id?: string;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & E) | ({
+    new (...args: any[]): {
+        id: number;
+        getId: () => any;
+        getIdObject: () => Object;
+        toJSON: () => Object;
+        toObject: (options?: import("@loopback/repository").Options) => Object;
+    };
+} & E);

package/dist/mixins/id.mixin.js

@@ -0,0 +1,58 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdMixin = exports.StringIdMixin = exports.NumberIdMixin = void 0;
+const utilities_1 = require("../utilities");
+const repository_1 = require("@loopback/repository");
+const NumberIdMixin = (superClass) => {
+    class Mixed extends superClass {
+    }
+    __decorate([
+        (0, repository_1.property)({
+            type: 'number',
+            id: true,
+            generated: true,
+        }),
+        __metadata("design:type", Number)
+    ], Mixed.prototype, "id", void 0);
+    return Mixed;
+};
+exports.NumberIdMixin = NumberIdMixin;
+const StringIdMixin = (superClass) => {
+    class Mixed extends superClass {
+    }
+    __decorate([
+        (0, repository_1.property)({
+            type: 'string',
+            id: true,
+            defaultFn: 'uuidv4',
+        }),
+        __metadata("design:type", String)
+    ], Mixed.prototype, "id", void 0);
+    return Mixed;
+};
+exports.StringIdMixin = StringIdMixin;
+const IdMixin = (superClass, opts) => {
+    switch (opts.idType) {
+        case 'string': {
+            return (0, exports.StringIdMixin)(superClass);
+        }
+        case 'number': {
+            return (0, exports.NumberIdMixin)(superClass);
+        }
+        default: {
+            throw (0, utilities_1.getError)({
+                message: `[IdMixin] Invalid id type | type: ${opts.idType} | Valids: ['string', 'number']`,
+            });
+        }
+    }
+};
+exports.IdMixin = IdMixin;

package/dist/mixins/index.d.ts

@@ -1,5 +1,6 @@
 export * from './data-type.mixin';
 export * from './duplicatable.mixin';
+export * from './id.mixin';
 export * from './object-search.mixin';
 export * from './principal.mixin';
 export * from './soft-delete.mixin';

package/dist/mixins/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-type.mixin"), exports);
 __exportStar(require("./duplicatable.mixin"), exports);
+__exportStar(require("./id.mixin"), exports);
 __exportStar(require("./object-search.mixin"), exports);
 __exportStar(require("./principal.mixin"), exports);
 __exportStar(require("./soft-delete.mixin"), exports);

package/dist/mixins/tz.mixin.d.ts

@@ -1,6 +1,15 @@
 import { MixinTarget } from '@loopback/core';
 import { Entity } from '@loopback/repository';
-export declare const TzMixin: <E extends MixinTarget<Entity>>(superClass: E) => {
+export declare const TzMixin: <E extends MixinTarget<Entity>>(superClass: E, opts?: {
+    createdAt: {
+        columnName: string;
+        dataType: string;
+    };
+    modifiedAt: {
+        columnName: string;
+        dataType: string;
+    };
+}) => {
     new (...args: any[]): {
         createdAt: Date;
         modifiedAt: Date;

package/dist/mixins/tz.mixin.js

@@ -11,15 +11,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TzMixin = void 0;
 const repository_1 = require("@loopback/repository");
-const TzMixin = (superClass) => {
+const TzMixin = (superClass, opts) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     class Mixed extends superClass {
     }
     __decorate([
         (0, repository_1.property)({
             type: 'date',
             postgresql: {
-                columnName: 'created_at',
-                dataType: 'TIMESTAMPTZ',
+                columnName: (_b = (_a = opts === null || opts === void 0 ? void 0 : opts.createdAt) === null || _a === void 0 ? void 0 : _a.columnName) !== null && _b !== void 0 ? _b : 'created_at',
+                dataType: (_d = (_c = opts === null || opts === void 0 ? void 0 : opts.createdAt) === null || _c === void 0 ? void 0 : _c.dataType) !== null && _d !== void 0 ? _d : 'TIMESTAMPTZ',
                 default: 'NOW()',
                 nullable: 'NO',
             },
@@ -30,8 +31,8 @@ const TzMixin = (superClass) => {
         (0, repository_1.property)({
             type: 'date',
             postgresql: {
-                columnName: 'modified_at',
-                dataType: 'TIMESTAMPTZ',
+                columnName: (_f = (_e = opts === null || opts === void 0 ? void 0 : opts.modifiedAt) === null || _e === void 0 ? void 0 : _e.columnName) !== null && _f !== void 0 ? _f : 'modified_at',
+                dataType: (_h = (_g = opts === null || opts === void 0 ? void 0 : opts.modifiedAt) === null || _g === void 0 ? void 0 : _g.dataType) !== null && _h !== void 0 ? _h : 'TIMESTAMPTZ',
                 default: 'NOW()',
                 nullable: 'NO',
             },

package/dist/mixins/user-audit.mixin.d.ts

@@ -1,8 +1,8 @@
-import { BaseTzEntity } from '../base/models';
+import { TBaseTzEntity } from '../base';
 import { IdType } from '../common/types';
 import { MixinTarget } from '@loopback/core';
 import { Entity, EntityResolver } from '@loopback/repository';
-export declare const UserAuditMixin: <E extends MixinTarget<Entity>, C extends BaseTzEntity = BaseTzEntity, M extends BaseTzEntity = BaseTzEntity>(superClass: E, opts?: {
+export declare const UserAuditMixin: <E extends MixinTarget<Entity>, C extends TBaseTzEntity = TBaseTzEntity, M extends TBaseTzEntity = TBaseTzEntity>(superClass: E, opts?: {
     useRelation: boolean;
     creatorResolver: EntityResolver<C>;
     creatorKeyTo?: string;

package/dist/utilities/model.utility.d.ts

@@ -1,6 +1,6 @@
 import { SchemaObject } from '@loopback/rest';
-import { BaseEntity, BaseIdEntity } from '../base/models/base.model';
-export declare const getIdSchema: <E extends BaseIdEntity>(entity: typeof BaseIdEntity & {
+import { BaseEntity } from '../base/models/base.model';
+export declare const getIdSchema: <E extends BaseEntity>(entity: typeof BaseEntity & {
     prototype: E;
 }) => SchemaObject;
 export declare const getIdType: <E extends BaseEntity>(entity: typeof BaseEntity & {

package/dist/utilities/query.utility.d.ts

@@ -1,6 +1,6 @@
-import { BaseTzEntity } from '../base';
+import { BaseEntity } from '../base';
 import { AnyType, EntityClassType } from '../common';
-export declare const getTableDefinition: <T extends BaseTzEntity>(opts: {
+export declare const getTableDefinition: <T extends BaseEntity>(opts: {
     model: EntityClassType<T>;
     alias?: string;
 }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minimaltech/node-infra",
-  "version": "0.5.9-24",
+  "version": "0.5.9-25",
   "description": "Minimal Technology - NodeJS Infrastructure - Loopback 4 Framework",
   "keywords": [
     "web",