@hexabot-ai/api 3.0.0-alpha.3

package/dist/utils/constants/session-store.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionStore = void 0;
+const connect_typeorm_1 = require("connect-typeorm");
+const express_session_1 = __importDefault(require("express-session"));
+const typeorm_1 = require("typeorm");
+const app_instance_1 = require("../../app.instance");
+const config_1 = require("../../config");
+const session_entity_1 = require("../../user/entities/session.entity");
+const toSeconds = (milliseconds) => Math.max(1, Math.floor(milliseconds / 1000));
+const logStoreError = (error) => {
+    if (config_1.config.env === 'test') {
+        return;
+    }
+    console.error('[session-store] TypeORM store error:', error);
+};
+const buildTypeormStore = () => {
+    if (!app_instance_1.AppInstance.isReady()) {
+        return new express_session_1.default.MemoryStore();
+    }
+    if (config_1.config.database.type === 'mongodb') {
+        throw new Error('TypeORM-backed session store is not available for MongoDB');
+    }
+    const app = app_instance_1.AppInstance.getApp();
+    const dataSource = app.get(typeorm_1.DataSource);
+    if (!dataSource.isInitialized) {
+        throw new Error('TypeORM data source is not initialized');
+    }
+    const repository = dataSource.getRepository(session_entity_1.SessionOrmEntity);
+    return new connect_typeorm_1.TypeormStore({
+        cleanupLimit: config_1.config.session.cleanupLimit,
+        limitSubquery: config_1.config.session.limitSubquery,
+        ttl: config_1.config.session.ttlSeconds ?? toSeconds(config_1.config.session.cookie.maxAge),
+        onError: (_store, error) => logStoreError(error),
+    }).connect(repository);
+};
+let sessionStore = null;
+const getSessionStore = () => {
+    if (!sessionStore) {
+        try {
+            sessionStore = buildTypeormStore();
+        }
+        catch (error) {
+            if (config_1.config.env !== 'test') {
+                console.warn('[session-store] Falling back to in-memory store:', error instanceof Error ? error.message : error);
+            }
+            sessionStore = new express_session_1.default.MemoryStore();
+        }
+    }
+    return sessionStore;
+};
+exports.getSessionStore = getSessionStore;
+//# sourceMappingURL=session-store.js.map

package/dist/utils/constants/session-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.js","sourceRoot":"","sources":["../../../src/utils/constants/session-store.ts"],"names":[],"mappings":";;;;;;AAMA,qDAA+C;AAC/C,sEAAsC;AACtC,qCAAqC;AAErC,qDAA6C;AAC7C,yCAAkC;AAClC,uEAAkE;AAElE,MAAM,SAAS,GAAG,CAAC,YAAoB,EAAU,EAAE,CACjD,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC,CAAC;AAC/C,MAAM,aAAa,GAAG,CAAC,KAAY,EAAE,EAAE;IACrC,IAAI,eAAM,CAAC,GAAG,KAAK,MAAM,EAAE,CAAC;QAC1B,OAAO;IACT,CAAC;IAED,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;AAC/D,CAAC,CAAC;AACF,MAAM,iBAAiB,GAAG,GAAkB,EAAE;IAC5C,IAAI,CAAC,0BAAW,CAAC,OAAO,EAAE,EAAE,CAAC;QAC3B,OAAO,IAAI,yBAAO,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,IAAI,eAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,0BAAW,CAAC,MAAM,EAAE,CAAC;IACjC,MAAM,UAAU,GAAG,GAAG,CAAC,GAAG,CAAC,oBAAU,CAAC,CAAC;IAEvC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,iCAAgB,CAAC,CAAC;IAE9D,OAAO,IAAI,8BAAY,CAAC;QACtB,YAAY,EAAE,eAAM,CAAC,OAAO,CAAC,YAAY;QACzC,aAAa,EAAE,eAAM,CAAC,OAAO,CAAC,aAAa;QAC3C,GAAG,EAAE,eAAM,CAAC,OAAO,CAAC,UAAU,IAAI,SAAS,CAAC,eAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;QACzE,OAAO,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC;KACjD,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AACzB,CAAC,CAAC;AAEF,IAAI,YAAY,GAAyB,IAAI,CAAC;AAEvC,MAAM,eAAe,GAAG,GAAkB,EAAE;IACjD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,IAAI,CAAC;YACH,YAAY,GAAG,iBAAiB,EAAE,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,eAAM,CAAC,GAAG,KAAK,MAAM,EAAE,CAAC;gBAE1B,OAAO,CAAC,IAAI,CACV,kDAAkD,EAClD,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAC/C,CAAC;YACJ,CAAC;YACD,YAAY,GAAG,IAAI,yBAAO,CAAC,WAAW,EAAE,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC;AAjBW,QAAA,eAAe,mBAiB1B"}

package/dist/utils/decorators/cacheable.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Cacheable(cacheKey: string): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/utils/decorators/cacheable.decorator.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cacheable = Cacheable;
+function Cacheable(cacheKey) {
+    return function (target, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const cache = this.cacheManager;
+            if (!cache) {
+                throw new Error('Cannot use Cacheable() decorator without injecting the cache manager.');
+            }
+            try {
+                const cachedResult = await cache.get(cacheKey);
+                if (cachedResult) {
+                    return cachedResult;
+                }
+            }
+            catch (error) {
+                console.error(`Cache get error for key: ${cacheKey}:`, error);
+            }
+            const result = await originalMethod.apply(this, args);
+            try {
+                await cache.set(cacheKey, result);
+            }
+            catch (error) {
+                console.error(`Cache set error for key: ${cacheKey}:`, error);
+            }
+            return result;
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=cacheable.decorator.js.map

package/dist/utils/decorators/cacheable.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheable.decorator.js","sourceRoot":"","sources":["../../../src/utils/decorators/cacheable.decorator.ts"],"names":[],"mappings":";;AAQA,8BA4CC;AA5CD,SAAgB,SAAS,CAAC,QAAgB;IACxC,OAAO,UACL,MAAW,EACX,YAAoB,EACpB,UAA8B;QAE9B,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QAExC,UAAU,CAAC,KAAK,GAAG,KAAK,WAAW,GAAG,IAAW;YAC/C,MAAM,KAAK,GAAsB,IAAI,CAAC,YAAY,CAAC;YAEnD,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CACb,uEAAuE,CACxE,CAAC;YACJ,CAAC;YAGD,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC/C,IAAI,YAAY,EAAE,CAAC;oBACjB,OAAO,YAAY,CAAC;gBACtB,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAEf,OAAO,CAAC,KAAK,CAAC,4BAA4B,QAAQ,GAAG,EAAE,KAAK,CAAC,CAAC;YAChE,CAAC;YAGD,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAGtD,IAAI,CAAC;gBACH,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACpC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAEf,OAAO,CAAC,KAAK,CAAC,4BAA4B,QAAQ,GAAG,EAAE,KAAK,CAAC,CAAC;YAChE,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/utils/decorators/is-uuid.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsUUIDv4(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/utils/decorators/is-uuid.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUUIDv4 = IsUUIDv4;
+const class_validator_1 = require("class-validator");
+function IsUUIDv4(validationOptions) {
+    return (0, class_validator_1.IsUUID)('4', validationOptions);
+}
+//# sourceMappingURL=is-uuid.decorator.js.map

package/dist/utils/decorators/is-uuid.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-uuid.decorator.js","sourceRoot":"","sources":["../../../src/utils/decorators/is-uuid.decorator.ts"],"names":[],"mappings":";;AAaA,4BAIC;AAXD,qDAA4D;AAO5D,SAAgB,QAAQ,CACtB,iBAAqC;IAErC,OAAO,IAAA,wBAAM,EAAC,GAAG,EAAE,iBAAiB,CAAC,CAAC;AACxC,CAAC"}

package/dist/utils/decorators/relation-ref.decorator.d.ts

@@ -0,0 +1,5 @@
+export interface AsRelationOptions {
+    idKey?: string;
+    allowArray?: boolean;
+}
+export declare function AsRelation(opts?: AsRelationOptions): PropertyDecorator;

package/dist/utils/decorators/relation-ref.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsRelation = AsRelation;
+const class_transformer_1 = require("class-transformer");
+function AsRelation(opts = {}) {
+    const idKey = opts.idKey ?? 'id';
+    const allowArray = opts.allowArray ?? true;
+    const toObj = (v) => typeof v === 'string' || typeof v === 'number' ? { [idKey]: v } : v;
+    return (0, class_transformer_1.Transform)(({ value }) => {
+        if (value == null)
+            return value;
+        if (allowArray && Array.isArray(value))
+            return value.map(toObj);
+        return toObj(value);
+    });
+}
+//# sourceMappingURL=relation-ref.decorator.js.map

package/dist/utils/decorators/relation-ref.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-ref.decorator.js","sourceRoot":"","sources":["../../../src/utils/decorators/relation-ref.decorator.ts"],"names":[],"mappings":";;AAeA,gCAYC;AArBD,yDAA8C;AAS9C,SAAgB,UAAU,CAAC,OAA0B,EAAE;IACrD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;IACjC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC;IAC3C,MAAM,KAAK,GAAG,CAAC,CAAM,EAAE,EAAE,CACvB,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAEtE,OAAO,IAAA,6BAAS,EAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;QAC7B,IAAI,KAAK,IAAI,IAAI;YAAE,OAAO,KAAK,CAAC;QAChC,IAAI,UAAU,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAEhE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/utils/decorators/roles.decorator.d.ts

@@ -0,0 +1,2 @@
+import { TRole } from '@/user/entities/role.entity';
+export declare const Roles: (...roles: TRole[]) => import("@nestjs/common").CustomDecorator<string>;

package/dist/utils/decorators/roles.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Roles = void 0;
+const common_1 = require("@nestjs/common");
+const Roles = (...roles) => (0, common_1.SetMetadata)('roles', roles);
+exports.Roles = Roles;
+//# sourceMappingURL=roles.decorator.js.map

package/dist/utils/decorators/roles.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.decorator.js","sourceRoot":"","sources":["../../../src/utils/decorators/roles.decorator.ts"],"names":[],"mappings":";;;AAMA,2CAA6C;AAItC,MAAM,KAAK,GAAG,CAAC,GAAG,KAAc,EAAE,EAAE,CAAC,IAAA,oBAAW,EAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AAA3D,QAAA,KAAK,SAAsD"}

package/dist/utils/decorators/validate.decorator.d.ts

@@ -0,0 +1,3 @@
+import { ValidationOptions } from 'class-validator';
+import { ZodArray, ZodType } from 'zod';
+export declare const Validate: (schema: ZodType | ZodArray<any>, validationOptions?: ValidationOptions) => (object: object, propertyName: string) => void;

package/dist/utils/decorators/validate.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = void 0;
+const class_validator_1 = require("class-validator");
+const zod_validation_1 = require("../helpers/zod-validation");
+const Validate = (schema, validationOptions) => (object, propertyName) => {
+    (0, class_validator_1.registerDecorator)({
+        target: object.constructor,
+        propertyName,
+        options: validationOptions,
+        constraints: [],
+        validator: {
+            validate(data, _validationArguments) {
+                return (0, zod_validation_1.buildZodSchemaValidator)(schema)(data);
+            },
+            defaultMessage(validationArguments) {
+                const { value, property } = validationArguments || {};
+                const { error, success } = schema.safeParse(value);
+                if (!success && error?.errors) {
+                    return error.errors
+                        .map((e) => `${[property, ...e.path].join('.')}: ${e.message}`)
+                        .join(', ');
+                }
+                return `${property}: Validation failed`;
+            },
+        },
+    });
+};
+exports.Validate = Validate;
+//# sourceMappingURL=validate.decorator.js.map

package/dist/utils/decorators/validate.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.decorator.js","sourceRoot":"","sources":["../../../src/utils/decorators/validate.decorator.ts"],"names":[],"mappings":";;;AAMA,qDAAuE;AAGvE,8DAAoE;AAE7D,MAAM,QAAQ,GACnB,CAAC,MAA+B,EAAE,iBAAqC,EAAE,EAAE,CAC3E,CAAC,MAAc,EAAE,YAAoB,EAAE,EAAE;IACvC,IAAA,mCAAiB,EAAC;QAChB,MAAM,EAAE,MAAM,CAAC,WAAW;QAC1B,YAAY;QACZ,OAAO,EAAE,iBAAiB;QAC1B,WAAW,EAAE,EAAE;QACf,SAAS,EAAE;YACT,QAAQ,CAAC,IAAI,EAAE,oBAAoB;gBACjC,OAAO,IAAA,wCAAuB,EAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;YAC/C,CAAC;YACD,cAAc,CAAC,mBAAmB;gBAChC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,mBAAmB,IAAI,EAAE,CAAC;gBACtD,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;gBACnD,IAAI,CAAC,OAAO,IAAI,KAAK,EAAE,MAAM,EAAE,CAAC;oBAC9B,OAAO,KAAK,CAAC,MAAM;yBAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;yBAC9D,IAAI,CAAC,IAAI,CAAC,CAAC;gBAChB,CAAC;gBAED,OAAO,GAAG,QAAQ,qBAAqB,CAAC;YAC1C,CAAC;SACF;KACF,CAAC,CAAC;AACL,CAAC,CAAC;AAzBS,QAAA,QAAQ,YAyBjB"}

package/dist/utils/generics/base-orm.controller.d.ts

@@ -0,0 +1,15 @@
+import { FindManyOptions } from 'typeorm';
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+import { LoggerService } from '@/logger/logger.service';
+import { DtoActionConfig, DtoTransformerConfig } from '../types/dto.types';
+import { BaseOrmService } from './base-orm.service';
+export declare abstract class BaseOrmController<Entity extends BaseOrmEntity, TransformerDto extends DtoTransformerConfig, ActionDto extends DtoActionConfig> {
+    protected readonly service: BaseOrmService<Entity, TransformerDto, ActionDto>;
+    eventEmitter: typeof this.service.eventEmitter;
+    readonly logger: LoggerService;
+    protected constructor(service: BaseOrmService<Entity, TransformerDto, ActionDto>);
+    protected canPopulate(populate: string[]): boolean;
+    count(options?: FindManyOptions<Entity>): Promise<{
+        count: number;
+    }>;
+}

package/dist/utils/generics/base-orm.controller.js

@@ -0,0 +1,32 @@
+"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.BaseOrmController = void 0;
+const common_1 = require("@nestjs/common");
+const logger_service_1 = require("../../logger/logger.service");
+class BaseOrmController {
+    constructor(service) {
+        this.service = service;
+        this.eventEmitter = service.eventEmitter;
+    }
+    canPopulate(populate) {
+        return this.service.canPopulate(populate);
+    }
+    async count(options) {
+        return { count: await this.service.count(options) };
+    }
+}
+exports.BaseOrmController = BaseOrmController;
+__decorate([
+    (0, common_1.Inject)(logger_service_1.LoggerService),
+    __metadata("design:type", logger_service_1.LoggerService)
+], BaseOrmController.prototype, "logger", void 0);
+//# sourceMappingURL=base-orm.controller.js.map

package/dist/utils/generics/base-orm.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-orm.controller.js","sourceRoot":"","sources":["../../../src/utils/generics/base-orm.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;AAMA,2CAAwC;AAIxC,gEAAwD;AAMxD,MAAsB,iBAAiB;IAUrC,YACqB,OAIlB;QAJkB,YAAO,GAAP,OAAO,CAIzB;QAED,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAC3C,CAAC;IAES,WAAW,CAAC,QAAkB;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,OAAiC;QAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;IACtD,CAAC;CACF;AA3BD,8CA2BC;AAnBU;IADR,IAAA,eAAM,EAAC,8BAAa,CAAC;8BACL,8BAAa;iDAAC"}

package/dist/utils/generics/base-orm.repository.d.ts

@@ -0,0 +1,82 @@
+import { EventEmitter2, IHookEntities, TNormalizedEvents } from '@nestjs/event-emitter';
+import { DeepPartial, EntityMetadata, EntitySubscriberInterface, FindManyOptions, FindOneOptions, InsertEvent, RemoveEvent, Repository, UpdateEvent } from 'typeorm';
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+import { LoggerService } from '@/logger/logger.service';
+import { DtoAction, DtoActionConfig, DtoTransformer, DtoTransformerConfig, InferActionDto, InferTransformDto } from '../types/dto.types';
+export type DeleteResult = {
+    acknowledged: boolean;
+    deletedCount: number;
+};
+export declare enum EHook {
+    preCreateValidate = "preCreateValidate",
+    preCreate = "preCreate",
+    preUpdateValidate = "preUpdateValidate",
+    preUpdate = "preUpdate",
+    preUpdateMany = "preUpdateMany",
+    preDelete = "preDelete",
+    postCreateValidate = "postCreateValidate",
+    postCreate = "postCreate",
+    postUpdateValidate = "postUpdateValidate",
+    postUpdate = "postUpdate",
+    postUpdateMany = "postUpdateMany",
+    postDelete = "postDelete"
+}
+export type UpdateOneOptions = {
+    upsert?: boolean;
+    shouldFlatten?: boolean;
+};
+export type FindAllOptions<EntityType> = Omit<FindManyOptions<EntityType>, 'where'> & {
+    where?: never;
+};
+export declare abstract class BaseOrmRepository<Entity extends BaseOrmEntity, TransformerDto extends DtoTransformerConfig, ActionDto extends DtoActionConfig> implements EntitySubscriberInterface<Entity> {
+    protected readonly repository: Repository<Entity>;
+    protected readonly populateRelations: string[];
+    protected readonly transformers: TransformerDto;
+    private readonly dataSource;
+    protected constructor(repository: Repository<Entity>, populateRelations: string[] | undefined, transformers: TransformerDto);
+    getPopulateRelations(): readonly string[];
+    canPopulate(populate: string[]): boolean;
+    getEventEmitter(): EventEmitter2;
+    protected readonly eventEmitter: EventEmitter2;
+    protected readonly logger: LoggerService;
+    getTransformer<D extends DtoTransformer>(t: D): (entity: Entity) => InferTransformDto<D, TransformerDto>;
+    actionDtoToEntity(data: InferActionDto<DtoAction, ActionDto>): DeepPartial<Entity>;
+    findAll(options?: FindAllOptions<Entity>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]>;
+    private findAllEntities;
+    findAllAndPopulate(options?: FindAllOptions<Entity>): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto>[]>;
+    find(options?: FindManyOptions<Entity>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]>;
+    private findEntities;
+    private withPopulateRelations;
+    findAndPopulate(options?: FindManyOptions<Entity>): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto>[]>;
+    count(options?: FindManyOptions<Entity>): Promise<number>;
+    findOne(idOrOptions: string | FindOneOptions<Entity>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto> | null>;
+    private findOneEntity;
+    findOneAndPopulate(idOrOptions: string | FindOneOptions<Entity>): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto> | null>;
+    create(payload: InferActionDto<DtoAction.Create, ActionDto>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>>;
+    createMany(payloads: InferActionDto<DtoAction.Create, ActionDto>[]): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]>;
+    updateOne(idOrOptions: string | FindOneOptions<Entity>, payload: InferActionDto<DtoAction.Update, ActionDto>, options?: UpdateOneOptions): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>>;
+    updateMany(options: FindManyOptions<Entity> | undefined, payload: InferActionDto<DtoAction.Update, ActionDto>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]>;
+    findOneOrCreate(idOrOptions: string | FindOneOptions<Entity>, payload: InferActionDto<DtoAction.Create, ActionDto>): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>>;
+    deleteMany(options?: FindManyOptions<Entity>): Promise<DeleteResult>;
+    deleteOne(idOrOptions: string | FindOneOptions<Entity>): Promise<DeleteResult>;
+    private isBuiltin;
+    listenTo(): Function;
+    private registerAsSubscriber;
+    private registerEntityManagerProvider;
+    protected getEventName(metadata: EntityMetadata, suffix: EHook): `hook:${IHookEntities}:${TNormalizedEvents}`;
+    protected emitHook(suffix: EHook, event: OrmLifecycleEvent<Entity>): Promise<void>;
+    protected onBeforeInsert(_event: InsertEvent<Entity>): Promise<void>;
+    protected onAfterInsert(_event: InsertEvent<Entity>): Promise<void>;
+    protected onBeforeUpdate(_event: UpdateEvent<Entity>): Promise<void>;
+    protected onAfterUpdate(_event: UpdateEvent<Entity>): Promise<void>;
+    protected onBeforeRemove(_event: RemoveEvent<Entity>): Promise<void>;
+    protected onAfterRemove(_event: RemoveEvent<Entity>): Promise<void>;
+    beforeInsert(event: InsertEvent<Entity>): Promise<void>;
+    afterInsert(event: InsertEvent<Entity>): Promise<void>;
+    beforeUpdate(event: UpdateEvent<Entity>): Promise<void>;
+    afterUpdate(event: UpdateEvent<Entity>): Promise<void>;
+    beforeRemove(event: RemoveEvent<Entity>): Promise<void>;
+    afterRemove(event: RemoveEvent<Entity>): Promise<void>;
+}
+type OrmLifecycleEvent<Entity extends BaseOrmEntity> = InsertEvent<Entity> | UpdateEvent<Entity> | RemoveEvent<Entity>;
+export {};

package/dist/utils/generics/base-orm.repository.js

@@ -0,0 +1,291 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseOrmRepository = exports.EHook = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const class_transformer_1 = require("class-transformer");
+const camelCase_1 = __importDefault(require("lodash/camelCase"));
+const set_1 = __importDefault(require("lodash/set"));
+const logger_service_1 = require("../../logger/logger.service");
+const flatten_1 = require("../helpers/flatten");
+const dto_types_1 = require("../types/dto.types");
+var EHook;
+(function (EHook) {
+    EHook["preCreateValidate"] = "preCreateValidate";
+    EHook["preCreate"] = "preCreate";
+    EHook["preUpdateValidate"] = "preUpdateValidate";
+    EHook["preUpdate"] = "preUpdate";
+    EHook["preUpdateMany"] = "preUpdateMany";
+    EHook["preDelete"] = "preDelete";
+    EHook["postCreateValidate"] = "postCreateValidate";
+    EHook["postCreate"] = "postCreate";
+    EHook["postUpdateValidate"] = "postUpdateValidate";
+    EHook["postUpdate"] = "postUpdate";
+    EHook["postUpdateMany"] = "postUpdateMany";
+    EHook["postDelete"] = "postDelete";
+})(EHook || (exports.EHook = EHook = {}));
+class BaseOrmRepository {
+    constructor(repository, populateRelations = [], transformers) {
+        this.repository = repository;
+        this.populateRelations = populateRelations;
+        this.transformers = transformers;
+        this.dataSource = repository.manager.connection;
+        this.registerEntityManagerProvider();
+        this.registerAsSubscriber();
+    }
+    getPopulateRelations() {
+        return this.populateRelations;
+    }
+    canPopulate(populate) {
+        if (!Array.isArray(populate) || populate.length === 0) {
+            return false;
+        }
+        return populate.every((relation) => this.populateRelations.includes(relation));
+    }
+    getEventEmitter() {
+        return this.eventEmitter;
+    }
+    getTransformer(t) {
+        return (entity) => {
+            return (0, class_transformer_1.plainToInstance)(this.transformers[t], entity, {
+                exposeUnsetFields: false,
+            });
+        };
+    }
+    actionDtoToEntity(data) {
+        const e = (0, class_transformer_1.plainToInstance)(this.repository.target, (0, class_transformer_1.instanceToPlain)(data));
+        return Object.assign(e);
+    }
+    async findAll(options = {}) {
+        const entities = await this.findAllEntities(options);
+        return entities.map(this.getTransformer(dto_types_1.DtoTransformer.PlainCls));
+    }
+    async findAllEntities(options = {}) {
+        return await this.repository.find(options);
+    }
+    async findAllAndPopulate(options = {}) {
+        const populatedEntities = await this.repository.find(this.withPopulateRelations(options, true));
+        return populatedEntities.map(this.getTransformer(dto_types_1.DtoTransformer.FullCls));
+    }
+    async find(options = {}) {
+        const entities = await this.findEntities(options);
+        return entities.map(this.getTransformer(dto_types_1.DtoTransformer.PlainCls));
+    }
+    async findEntities(options = {}, populate = false) {
+        const finalOptions = this.withPopulateRelations(options, populate);
+        return await this.repository.find(finalOptions);
+    }
+    withPopulateRelations(options, populate) {
+        if (!populate || this.populateRelations.length === 0) {
+            return options;
+        }
+        const finalOptions = { ...(options ?? {}) };
+        const currentRelations = finalOptions.relations;
+        if (!currentRelations) {
+            finalOptions.relations = this.populateRelations;
+            return finalOptions;
+        }
+        if (Array.isArray(currentRelations)) {
+            finalOptions.relations = Array.from(new Set([...currentRelations, ...this.populateRelations]));
+        }
+        return finalOptions;
+    }
+    async findAndPopulate(options = {}) {
+        const entities = await this.findEntities(options, true);
+        return entities.map(this.getTransformer(dto_types_1.DtoTransformer.FullCls));
+    }
+    async count(options = {}) {
+        return await this.repository.count(options);
+    }
+    async findOne(idOrOptions) {
+        const entity = await this.findOneEntity(idOrOptions);
+        return entity ? this.getTransformer(dto_types_1.DtoTransformer.PlainCls)(entity) : null;
+    }
+    async findOneEntity(idOrOptions, populate = false) {
+        if (typeof idOrOptions === 'string') {
+            const options = this.withPopulateRelations({
+                where: { id: idOrOptions },
+            }, populate);
+            return (await this.repository.findOne(options)) ?? null;
+        }
+        const options = this.withPopulateRelations(idOrOptions, populate);
+        return (await this.repository.findOne(options)) ?? null;
+    }
+    async findOneAndPopulate(idOrOptions) {
+        const entity = await this.findOneEntity(idOrOptions, true);
+        return entity ? this.getTransformer(dto_types_1.DtoTransformer.FullCls)(entity) : null;
+    }
+    async create(payload) {
+        const entity = this.repository.create(this.actionDtoToEntity(payload));
+        const created = await this.repository.save(entity);
+        return this.getTransformer(dto_types_1.DtoTransformer.PlainCls)(created);
+    }
+    async createMany(payloads) {
+        const entities = this.repository.create(payloads.map((payload) => this.actionDtoToEntity(payload)));
+        const created = await this.repository.save(entities);
+        return created.map(this.getTransformer(dto_types_1.DtoTransformer.PlainCls));
+    }
+    async updateOne(idOrOptions, payload, options) {
+        const entity = await this.findOneEntity(idOrOptions);
+        if (entity) {
+            const updates = this.actionDtoToEntity(payload);
+            if (options?.shouldFlatten && updates && typeof updates === 'object') {
+                const flattenedUpdates = (0, flatten_1.flatten)(updates);
+                const target = entity;
+                for (const [path, value] of Object.entries(flattenedUpdates)) {
+                    (0, set_1.default)(target, path, value);
+                }
+            }
+            else {
+                Object.assign(entity, updates);
+            }
+            const updated = await this.repository.save(entity);
+            if (updated) {
+                return this.getTransformer(dto_types_1.DtoTransformer.PlainCls)(updated);
+            }
+            else {
+                throw new common_1.NotFoundException('Unable to execute updateOne() - No updates');
+            }
+        }
+        if (options?.upsert) {
+            return await this.create(payload);
+        }
+        else {
+            throw new common_1.NotFoundException('Unable to execute updateOne() - No updates');
+        }
+    }
+    async updateMany(options = {}, payload) {
+        const entities = await this.findEntities(options);
+        if (!entities.length) {
+            return [];
+        }
+        const changes = this.actionDtoToEntity(payload);
+        for (let index = 0; index < entities.length; index++) {
+            Object.assign(entities[index], changes);
+        }
+        const updatedEntities = await this.repository.save(entities);
+        const toDto = this.getTransformer(dto_types_1.DtoTransformer.PlainCls);
+        return updatedEntities.map(toDto);
+    }
+    async findOneOrCreate(idOrOptions, payload) {
+        const existing = await this.findOneEntity(idOrOptions);
+        if (existing) {
+            return this.getTransformer(dto_types_1.DtoTransformer.PlainCls)(existing);
+        }
+        return await this.create(payload);
+    }
+    async deleteMany(options = {}) {
+        const matches = await this.repository.find(options);
+        if (matches.length === 0) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        const deletable = matches.filter((entity) => !this.isBuiltin(entity));
+        if (!deletable.length) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        await this.repository.remove(deletable);
+        const result = {
+            acknowledged: true,
+            deletedCount: deletable.length,
+        };
+        return result;
+    }
+    async deleteOne(idOrOptions) {
+        const entity = await this.findOneEntity(idOrOptions);
+        if (!entity || this.isBuiltin(entity)) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        await this.repository.remove(entity);
+        const result = {
+            acknowledged: true,
+            deletedCount: 1,
+        };
+        return result;
+    }
+    isBuiltin(entity) {
+        return entity.builtin === true;
+    }
+    listenTo() {
+        return this.repository.target;
+    }
+    registerAsSubscriber() {
+        const alreadyRegistered = this.dataSource.subscribers.some((subscriber) => subscriber === this);
+        if (!alreadyRegistered) {
+            this.dataSource.subscribers.push(this);
+        }
+    }
+    registerEntityManagerProvider() {
+        const target = this.repository.target;
+        if (typeof target !== 'function') {
+            return;
+        }
+        const entityConstructor = target;
+        if (typeof entityConstructor.registerEntityManagerProvider !== 'function') {
+            return;
+        }
+        entityConstructor.registerEntityManagerProvider(() => this.repository.manager);
+    }
+    getEventName(metadata, suffix) {
+        const entityName = (0, camelCase_1.default)((metadata.name ?? 'entity').replace(/OrmEntity$/, '')) ||
+            'entity';
+        return `hook:${entityName}:${suffix}`;
+    }
+    async emitHook(suffix, event) {
+        if (!this.eventEmitter)
+            return;
+        const eventName = this.getEventName(event.metadata, suffix);
+        await this.eventEmitter.emitAsync(eventName, event);
+    }
+    async onBeforeInsert(_event) { }
+    async onAfterInsert(_event) { }
+    async onBeforeUpdate(_event) { }
+    async onAfterUpdate(_event) { }
+    async onBeforeRemove(_event) { }
+    async onAfterRemove(_event) { }
+    async beforeInsert(event) {
+        await this.onBeforeInsert(event);
+        await this.emitHook(EHook.preCreate, event);
+    }
+    async afterInsert(event) {
+        await this.onAfterInsert(event);
+        await this.emitHook(EHook.postCreate, event);
+    }
+    async beforeUpdate(event) {
+        await this.onBeforeUpdate(event);
+        await this.emitHook(EHook.preUpdate, event);
+    }
+    async afterUpdate(event) {
+        await this.onAfterUpdate(event);
+        await this.emitHook(EHook.postUpdate, event);
+    }
+    async beforeRemove(event) {
+        await this.onBeforeRemove(event);
+        await this.emitHook(EHook.preDelete, event);
+    }
+    async afterRemove(event) {
+        await this.onAfterRemove(event);
+        await this.emitHook(EHook.postDelete, event);
+    }
+}
+exports.BaseOrmRepository = BaseOrmRepository;
+__decorate([
+    (0, common_1.Inject)(event_emitter_1.EventEmitter2),
+    __metadata("design:type", event_emitter_1.EventEmitter2)
+], BaseOrmRepository.prototype, "eventEmitter", void 0);
+__decorate([
+    (0, common_1.Inject)(logger_service_1.LoggerService),
+    __metadata("design:type", logger_service_1.LoggerService)
+], BaseOrmRepository.prototype, "logger", void 0);
+//# sourceMappingURL=base-orm.repository.js.map