@flusys/nestjs-shared 6.4.0 → 7.0.0-beta.1

package/cjs/classes/hybrid-event-bus.class.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HybridEventBus", {
+    enumerable: true,
+    get: function() {
+        return HybridEventBus;
+    }
+});
+const _config = require("@flusys/nestjs-core/config");
+const _common = require("@nestjs/common");
+const _eventpatternutil = require("../utils/event-pattern.util");
+const _eventtransportregistry = require("./event-transports/event-transport.registry");
+const _memorytransport = require("./event-transports/memory-transport");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const DEFAULT_DEDUPE_SIZE = 5000;
+let HybridEventBus = class HybridEventBus {
+    getTransportLabel() {
+        return this.label;
+    }
+    getActiveTransports() {
+        return this.transports.map((transport)=>transport.name);
+    }
+    async connect() {
+        if (this.connected) return;
+        if (!this.connecting) {
+            this.connecting = this.buildTransports().catch((error)=>{
+                // A cached rejection would leave the bus dead for the process lifetime
+                this.connecting = undefined;
+                throw error;
+            });
+        }
+        await this.connecting;
+        this.connected = true;
+    }
+    async publish(event) {
+        if (!await this.ensureConnected()) return;
+        await Promise.all(this.transports.map((transport)=>transport.publish(event).catch((error)=>{
+                this.logger.warn(`Publish failed on ${transport.name}: ${error.message}`);
+            })));
+    }
+    async subscribe(pattern, handler) {
+        this.subscriptions.push({
+            pattern,
+            handler: handler
+        });
+        if (!await this.ensureConnected()) return;
+        await Promise.all(this.transports.map((transport)=>transport.bind(pattern).catch((error)=>{
+                this.logger.warn(`Bind failed on ${transport.name}: ${error.message}`);
+            })));
+    }
+    async close() {
+        await Promise.allSettled(this.transports.map((transport)=>transport.close()));
+        this.transports.length = 0;
+        this.subscriptions.length = 0;
+        this.seenIds.clear();
+        this.seenOrder.length = 0;
+        this.memory = undefined;
+        this.connecting = undefined;
+        this.connected = false;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    /**
+   * Connecting must never throw at the call site - a bus that cannot start is
+   * a degraded system, not a failed request. The next call retries.
+   */ async ensureConnected() {
+        try {
+            await this.connect();
+            return true;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Event bus is not available: ${message}`);
+            return false;
+        }
+    }
+    resolveLabelFromEnv() {
+        const value = _config.envConfig.tryGetValue('USE_EVENT_LABEL', false) || 'memory';
+        return value;
+    }
+    async buildTransports() {
+        if (this.label === 'memory' || this.label === 'hybrid') {
+            this.memory = new _memorytransport.MemoryTransport();
+            await this.memory.connect();
+            this.registerTransport(this.memory);
+        }
+        if (this.label !== 'memory') {
+            const broker = await this.createBrokerTransport(this.label);
+            if (broker) {
+                this.registerTransport(broker);
+            } else {
+                this.logger.error(`Event transport '${this.label}' was requested but is unavailable - delivering ` + `in-process only, so no event will reach another service. Check the broker URL ` + `and that its driver is installed.`);
+                if (!this.memory) {
+                    this.memory = new _memorytransport.MemoryTransport();
+                    await this.memory.connect();
+                    this.registerTransport(this.memory);
+                }
+            }
+        }
+    }
+    async createBrokerTransport(label) {
+        const name = label === 'hybrid' ? this.resolveHybridBrokerName() : label;
+        try {
+            await this.loadOptionalTransport(name);
+            const factory = _eventtransportregistry.EventTransportRegistry.get(name);
+            if (!factory) {
+                this.logger.error(`Event transport '${name}' is not registered. Available: ${_eventtransportregistry.EventTransportRegistry.getAll().join(', ')}`);
+                return undefined;
+            }
+            const transport = factory(this.getTransportConfig(name));
+            await transport.connect();
+            return transport;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to start the '${name}' event transport: ${message}`);
+            return undefined;
+        }
+    }
+    resolveHybridBrokerName() {
+        return _config.envConfig.tryGetValue('EVENT_BROKER', false) || 'rabbitmq';
+    }
+    /**
+   * Registers explicitly rather than relying on the transport file's own
+   * side effect, which a tree shaking bundler is free to drop.
+   */ async loadOptionalTransport(name) {
+        if (_eventtransportregistry.EventTransportRegistry.has(name)) return;
+        if (name === 'rabbitmq') {
+            const { RabbitMqTransport } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./event-transports/rabbitmq-transport.optional")));
+            _eventtransportregistry.EventTransportRegistry.register('rabbitmq', (config)=>new RabbitMqTransport(config));
+            return;
+        }
+        if (name === 'kafka') {
+            const { KafkaTransport } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./event-transports/kafka-transport.optional")));
+            _eventtransportregistry.EventTransportRegistry.register('kafka', (config)=>new KafkaTransport(config));
+        }
+    }
+    getTransportConfig(name) {
+        if (name === 'rabbitmq') {
+            return {
+                url: _config.envConfig.tryGetValue('RABBITMQ_URL', false) || undefined,
+                queue: this.options.serviceName ? `${this.options.serviceName}.events` : undefined,
+                ...this.options.rabbitmq ?? {}
+            };
+        }
+        if (name === 'kafka') {
+            return {
+                brokers: this.parseBrokers(_config.envConfig.tryGetValue('KAFKA_BROKERS', false)),
+                clientId: this.options.serviceName,
+                groupId: this.options.serviceName ? `${this.options.serviceName}-events` : undefined,
+                ...this.options.kafka ?? {}
+            };
+        }
+        return {};
+    }
+    parseBrokers(value) {
+        if (!value) return undefined;
+        return value.split(',').map((broker)=>broker.trim()).filter(Boolean);
+    }
+    registerTransport(transport) {
+        transport.onMessage((event)=>this.dispatch(event));
+        this.transports.push(transport);
+    }
+    async dispatch(event) {
+        if (this.isDuplicate(event.id)) return;
+        const matched = this.subscriptions.filter((subscription)=>(0, _eventpatternutil.matchEventPattern)(subscription.pattern, event.name));
+        await Promise.all(matched.map(async (subscription)=>{
+            try {
+                await subscription.handler(event);
+            } catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                this.logger.error(`Handler for '${subscription.pattern}' failed: ${message}`);
+            }
+        }));
+    }
+    isDuplicate(eventId) {
+        if (!eventId) return false;
+        if (this.seenIds.has(eventId)) return true;
+        this.seenIds.add(eventId);
+        this.seenOrder.push(eventId);
+        if (this.seenOrder.length > this.dedupeSize) {
+            const evicted = this.seenOrder.shift();
+            if (evicted) this.seenIds.delete(evicted);
+        }
+        return false;
+    }
+    constructor(options = {}){
+        _define_property(this, "options", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "subscriptions", void 0);
+        _define_property(this, "transports", void 0);
+        _define_property(this, "seenIds", void 0);
+        _define_property(this, "seenOrder", void 0);
+        _define_property(this, "label", void 0);
+        _define_property(this, "dedupeSize", void 0);
+        _define_property(this, "memory", void 0);
+        _define_property(this, "connecting", void 0);
+        _define_property(this, "connected", void 0);
+        this.options = options;
+        this.logger = new _common.Logger(HybridEventBus.name);
+        this.subscriptions = [];
+        this.transports = [];
+        this.seenIds = new Set();
+        this.seenOrder = [];
+        this.connected = false;
+        this.label = options.transport ?? this.resolveLabelFromEnv();
+        this.dedupeSize = options.dedupeSize ?? DEFAULT_DEDUPE_SIZE;
+    }
+};

package/cjs/classes/hybrid-event-bus.class.spec.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventactionenum = require("../enums/event-action.enum");
+const _eventtransportregistry = require("./event-transports/event-transport.registry");
+const _memorytransport = require("./event-transports/memory-transport");
+const _hybrideventbusclass = require("./hybrid-event-bus.class");
+function buildEvent(name = 'storage.folder.created', id = 'event-1') {
+    return {
+        id,
+        name,
+        module: 'storage',
+        entity: 'folder',
+        action: _eventactionenum.EventAction.CREATED,
+        payload: {
+            ids: [
+                '1'
+            ]
+        },
+        actor: {},
+        occurredAt: new Date().toISOString(),
+        version: 1
+    };
+}
+function createFakeTransport(name) {
+    const handlers = [];
+    const transport = {
+        name,
+        connect: jest.fn().mockResolvedValue(undefined),
+        publish: jest.fn().mockResolvedValue(undefined),
+        bind: jest.fn().mockResolvedValue(undefined),
+        onMessage: (handler)=>handlers.push(handler),
+        close: jest.fn().mockResolvedValue(undefined),
+        isReady: ()=>true,
+        emit: (event)=>handlers.forEach((handler)=>handler(event))
+    };
+    return transport;
+}
+describe('HybridEventBus', ()=>{
+    const originalLabel = process.env.USE_EVENT_LABEL;
+    afterEach(async ()=>{
+        _eventtransportregistry.EventTransportRegistry.clear();
+        if (originalLabel === undefined) delete process.env.USE_EVENT_LABEL;
+        else process.env.USE_EVENT_LABEL = originalLabel;
+    });
+    it('should default to the memory transport', async ()=>{
+        const bus = new _hybrideventbusclass.HybridEventBus();
+        await bus.connect();
+        expect(bus.getTransportLabel()).toBe('memory');
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        await bus.close();
+    });
+    it('should read the transport label from USE_EVENT_LABEL when not given explicitly', ()=>{
+        process.env.USE_EVENT_LABEL = 'kafka';
+        expect(new _hybrideventbusclass.HybridEventBus().getTransportLabel()).toBe('kafka');
+    });
+    it('should prefer an explicit transport option over the env value', ()=>{
+        process.env.USE_EVENT_LABEL = 'kafka';
+        expect(new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        }).getTransportLabel()).toBe('memory');
+    });
+    it('should deliver a published event to a matching subscriber', async ()=>{
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('storage.*.created', handler);
+        await bus.publish(buildEvent());
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'storage.folder.created'
+        }));
+        await bus.close();
+    });
+    it('should not deliver an event to a non matching subscriber', async ()=>{
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('auth.#', handler);
+        await bus.publish(buildEvent());
+        expect(handler).not.toHaveBeenCalled();
+        await bus.close();
+    });
+    it('should keep publishing when a handler throws', async ()=>{
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        const failing = jest.fn().mockRejectedValue(new Error('boom'));
+        const healthy = jest.fn();
+        await bus.subscribe('**', failing);
+        await bus.subscribe('**', healthy);
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        expect(healthy).toHaveBeenCalled();
+        await bus.close();
+    });
+    it('should publish to both layers in hybrid mode and deliver each event once', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'hybrid'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('**', handler);
+        expect(bus.getActiveTransports()).toEqual([
+            'memory',
+            'rabbitmq'
+        ]);
+        const event = buildEvent();
+        await bus.publish(event);
+        // the broker loops the same event back to this process
+        broker.emit(event);
+        expect(broker.publish).toHaveBeenCalledWith(event);
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should fall back to memory when the broker cannot start', async ()=>{
+        _eventtransportregistry.EventTransportRegistry.register('kafka', ()=>{
+            throw new Error('kafkajs not installed');
+        });
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'kafka'
+        });
+        await bus.connect();
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        await bus.close();
+    });
+    it('should survive a transport that fails to publish', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        broker.publish.mockRejectedValue(new Error('channel closed'));
+        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'rabbitmq'
+        });
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        await bus.close();
+    });
+    it('should not publish or throw while it has no working transport', async ()=>{
+        const connectSpy = jest.spyOn(_memorytransport.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        expect(bus.getActiveTransports()).toEqual([]);
+        connectSpy.mockRestore();
+        await bus.close();
+    });
+    it('should retry connecting after a failed attempt instead of staying dead', async ()=>{
+        const connectSpy = jest.spyOn(_memorytransport.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.publish(buildEvent());
+        connectSpy.mockRestore();
+        await bus.subscribe('**', handler);
+        await bus.publish(buildEvent('storage.folder.created', 'event-2'));
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should keep a subscription made while disconnected so a later connect binds it', async ()=>{
+        const connectSpy = jest.spyOn(_memorytransport.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await expect(bus.subscribe('**', handler)).resolves.toBeUndefined();
+        connectSpy.mockRestore();
+        await bus.publish(buildEvent());
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should forget its transports after close', async ()=>{
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'memory'
+        });
+        await bus.connect();
+        await bus.close();
+        expect(bus.getActiveTransports()).toEqual([]);
+    });
+});

package/cjs/classes/index.js

@@ -4,8 +4,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./api-controller.class"), exports);
 _export_star(require("./api-service.class"), exports);
+_export_star(require("./disabled-event-bus.class"), exports);
+_export_star(require("./domain-event.publisher"), exports);
+_export_star(require("./event-bus.registry"), exports);
+_export_star(require("./event-transports"), exports);
 _export_star(require("./handle-custome-db"), exports);
 _export_star(require("./hybrid-cache.class"), exports);
+_export_star(require("./hybrid-event-bus.class"), exports);
 _export_star(require("./winston.logger.class"), exports);
 _export_star(require("../constants/permissions"), exports);
 function _export_star(from, to) {

package/cjs/constants/index.js

@@ -16,6 +16,24 @@ _export(exports, {
     get CLIENT_TYPE_HEADER () {
         return CLIENT_TYPE_HEADER;
     },
+    get DEFAULT_EVENT_EXCHANGE () {
+        return DEFAULT_EVENT_EXCHANGE;
+    },
+    get DEFAULT_EVENT_SERVICE_NAME () {
+        return DEFAULT_EVENT_SERVICE_NAME;
+    },
+    get DEFAULT_EVENT_TOPIC () {
+        return DEFAULT_EVENT_TOPIC;
+    },
+    get DOMAIN_EVENT_HANDLER_KEY () {
+        return DOMAIN_EVENT_HANDLER_KEY;
+    },
+    get EVENT_BUS_INSTANCE () {
+        return EVENT_BUS_INSTANCE;
+    },
+    get EVENT_BUS_MODULE_OPTIONS () {
+        return EVENT_BUS_MODULE_OPTIONS;
+    },
     get IDEMPOTENCY_CACHE_PREFIX () {
         return IDEMPOTENCY_CACHE_PREFIX;
     },
@@ -55,10 +73,16 @@ function _export_star(from, to) {
 }
 const IS_PUBLIC_KEY = 'isPublic';
 const PERMISSIONS_KEY = 'permissions';
+const DOMAIN_EVENT_HANDLER_KEY = 'domainEventHandler';
 const CACHE_INSTANCE = 'CACHE_INSTANCE';
 const PERMISSION_GUARD_CONFIG = 'PERMISSION_GUARD_CONFIG';
+const EVENT_BUS_INSTANCE = 'EVENT_BUS_INSTANCE';
+const EVENT_BUS_MODULE_OPTIONS = 'EVENT_BUS_MODULE_OPTIONS';
 const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 const REQUEST_ID_HEADER = 'x-request-id';
 const CLIENT_TYPE_HEADER = 'x-client-type';
 const PERMISSIONS_CACHE_PREFIX = 'my-permissions';
 const IDEMPOTENCY_CACHE_PREFIX = 'idempotency';
+const DEFAULT_EVENT_EXCHANGE = 'flusys.events';
+const DEFAULT_EVENT_TOPIC = 'flusys.domain-events';
+const DEFAULT_EVENT_SERVICE_NAME = 'flusys';

package/cjs/decorators/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./api-response.decorator"), exports);
 _export_star(require("./current-user.decorator"), exports);
 _export_star(require("./log-action.decorator"), exports);
+_export_star(require("./on-domain-event.decorator"), exports);
 _export_star(require("./public.decorator"), exports);
 _export_star(require("./require-permission.decorator"), exports);
 function _export_star(from, to) {

package/cjs/decorators/on-domain-event.decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OnDomainEvent", {
+    enumerable: true,
+    get: function() {
+        return OnDomainEvent;
+    }
+});
+const _common = require("@nestjs/common");
+const _constants = require("../constants");
+const OnDomainEvent = (...patterns)=>(0, _common.SetMetadata)(_constants.DOMAIN_EVENT_HANDLER_KEY, patterns);

package/cjs/decorators/on-domain-event.decorator.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _constants = require("../constants");
+const _ondomaineventdecorator = require("./on-domain-event.decorator");
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let TestConsumer = class TestConsumer {
+    handleCreated() {}
+    handleDeleted() {}
+    handlePlain() {}
+};
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('storage.folder.created'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], TestConsumer.prototype, "handleCreated", null);
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('auth.*.deleted', 'iam.*.deleted'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], TestConsumer.prototype, "handleDeleted", null);
+describe('OnDomainEvent', ()=>{
+    it('should attach a single pattern as metadata', ()=>{
+        const patterns = Reflect.getMetadata(_constants.DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleCreated);
+        expect(patterns).toEqual([
+            'storage.folder.created'
+        ]);
+    });
+    it('should attach every pattern passed to the decorator', ()=>{
+        const patterns = Reflect.getMetadata(_constants.DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleDeleted);
+        expect(patterns).toEqual([
+            'auth.*.deleted',
+            'iam.*.deleted'
+        ]);
+    });
+    it('should leave undecorated methods without metadata', ()=>{
+        expect(Reflect.getMetadata(_constants.DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handlePlain)).toBeUndefined();
+    });
+});

package/cjs/entities/user-root.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "UserRoot", {
         return UserRoot;
     }
 });
-const _nestjsshared = require("@flusys/nestjs-shared");
+const _handlecustomedb = require("../classes/handle-custome-db");
 const _typeorm = require("typeorm");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -135,7 +135,7 @@ _ts_decorate([
 ], UserRoot.prototype, "lastLoginAt", void 0);
 _ts_decorate([
     (0, _typeorm.Column)({
-        type: (0, _nestjsshared.getJsonColumnType)(),
+        type: (0, _handlecustomedb.getJsonColumnType)(),
         nullable: true,
         name: 'additional_fields'
     }),

package/cjs/enums/event-action.enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventAction", {
+    enumerable: true,
+    get: function() {
+        return EventAction;
+    }
+});
+var EventAction = /*#__PURE__*/ function(EventAction) {
+    EventAction["CREATED"] = "created";
+    EventAction["UPDATED"] = "updated";
+    EventAction["DELETED"] = "deleted";
+    EventAction["RESTORED"] = "restored";
+    EventAction["PURGED"] = "purged";
+    return EventAction;
+}({});

package/cjs/enums/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./event-action.enum"), exports);
 _export_star(require("./notification-type.enum"), exports);
 _export_star(require("./participant-status.enum"), exports);
 _export_star(require("./recurrence-type.enum"), exports);

package/cjs/interfaces/event-bus.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/cjs/interfaces/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./ai-assistant-adapter.interface"), exports);
 _export_star(require("./api.interface"), exports);
 _export_star(require("./datasource.interface"), exports);
+_export_star(require("./event-bus.interface"), exports);
 _export_star(require("./event-manager-adapter.interface"), exports);
 _export_star(require("./identity.interface"), exports);
 _export_star(require("./logged-user-info.interface"), exports);