@messenger-box/platform-server 10.0.3-alpha.2 → 10.0.3-alpha.201

package/lib/services/proxy-services/ExtendedTokenAccountProxyService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtendedTokenAccountProxyService.js","sources":["../../../src/services/proxy-services/ExtendedTokenAccountProxyService.ts"],"sourcesContent":[null],"names":[],"mappings":"0SAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AAGI,IAAM,gCAAgC,GAAtC,MAAM,gCAAgC,CAAA;aACzC,CAAA,MAEI,EAAqB,MAErB,EAAyB;AAEzB,IAAA,MAAA,WAAM,GAAA,MAAc,CAAA,KAAO,CAAA;eAC3B,EAAA;;;IAQP,oBAAA,CAAA,IAAA,EAAA,kCAAA,EAAA,MAAA,EAAA,WAAA,CAAA;AAhBY,EAAA;AAFZ;gCACD,GAAA,UAAA,CAAA,CAAA,UAAA;;AAGS,EAAA,OAAA,CAAA,CAAA,EAAA,iBAAO,CAAA,gBAAW,CAAA,CAAgB,EAAC,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,aAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,gCAAA,CAAA"}

package/lib/services/proxy-services/MessengerNotificationProxyService.d.ts

@@ -0,0 +1,44 @@
+import { ServiceBroker } from 'moleculer';
+import type { CdmLogger } from '@cdm-logger/core';
+import type { IMessengerNotificationService } from 'common/server';
+/**
+ * Client-side proxy for MessengerNotification operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IMessengerNotificationService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IMessengerNotificationService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles comprehensive notification management within the messenger platform,
+ * providing operations for sending various types of notifications including email, SMS,
+ * push notifications, and Expo notifications across different messaging contexts through
+ * service broker delegation.
+ *
+ * Key capabilities:
+ * - Multi-channel notification delivery (email, SMS, push, Expo)
+ * - Unread message notification scheduling and management
+ * - User preference-based notification filtering
+ * - Support service notification handling
+ * - Alert message notification broadcasting
+ * - Thread-based notification management
+ * - Real-time push notification integration
+ * - Template-based notification customization
+ * - Channel and post-based notification routing
+ * - User aggregation and preference management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IMessengerNotificationService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using MessengerNotificationServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see MessengerNotificationService for actual implementation
+ * @see MessengerNotificationMoleculerService for Moleculer service layer
+ */
+export declare class MessengerNotificationProxyService {
+    constructor(broker: ServiceBroker, logger: CdmLogger.ILogger);
+}
+export interface MessengerNotificationProxyService extends IMessengerNotificationService {
+}

package/lib/services/proxy-services/MessengerNotificationProxyService.js

@@ -0,0 +1,54 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {generateProxyMethods}from'@common-stack/codegen-zod';/**
+ * Local schemas - topic follows convention: IMessengerNotificationService → MessengerNotificationService
+ */
+const MessengerNotificationServiceSchemas = {
+  topic: 'MessengerNotificationService'
+};
+/**
+ * Client-side proxy for MessengerNotification operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IMessengerNotificationService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IMessengerNotificationService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles comprehensive notification management within the messenger platform,
+ * providing operations for sending various types of notifications including email, SMS,
+ * push notifications, and Expo notifications across different messaging contexts through
+ * service broker delegation.
+ *
+ * Key capabilities:
+ * - Multi-channel notification delivery (email, SMS, push, Expo)
+ * - Unread message notification scheduling and management
+ * - User preference-based notification filtering
+ * - Support service notification handling
+ * - Alert message notification broadcasting
+ * - Thread-based notification management
+ * - Real-time push notification integration
+ * - Template-based notification customization
+ * - Channel and post-based notification routing
+ * - User aggregation and preference management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IMessengerNotificationService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using MessengerNotificationServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see MessengerNotificationService for actual implementation
+ * @see MessengerNotificationMoleculerService for Moleculer service layer
+ */
+let MessengerNotificationProxyService = class MessengerNotificationProxyService {
+  constructor(broker, logger) {
+    const childLogger = logger.child({
+      className: 'MessengerNotificationProxyService'
+    });
+    // ⚡ ONE LINE: Auto-generate all proxy methods
+    generateProxyMethods(this, MessengerNotificationServiceSchemas, broker, childLogger);
+  }
+};
+MessengerNotificationProxyService = __decorate([injectable()
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+, __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], MessengerNotificationProxyService);export{MessengerNotificationProxyService};//# sourceMappingURL=MessengerNotificationProxyService.js.map

package/lib/services/proxy-services/MessengerNotificationProxyService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerNotificationProxyService.js","sources":["../../../src/services/proxy-services/MessengerNotificationProxyService.ts"],"sourcesContent":[null],"names":[],"mappings":"2OAOA;;AAEG;AACH,MAAM,mCAAmC,GAAG;AACxC,EAAA,KAAA,EAAK;CACR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AAGI,IAAM,iCAAiC,GAAvC,MAAM,iCAAiC,CAAA;aAC1C,CAAA,MAEI,EAAqB,MAErB,EAAyB;AAEzB,IAAA,MAAA,WAAM,GAAA,MAAc,CAAA,KAAO,CAAA;eAC3B,EAAA;;;IAQP,oBAAA,CAAA,IAAA,EAAA,mCAAA,EAAA,MAAA,EAAA,WAAA,CAAA;AAhBY,EAAA;AAFZ;iCACD,GAAA,UAAA,CAAA,CAAA,UAAA;;AAGS,EAAA,OAAA,CAAA,CAAA,EAAA,iBAAO,CAAA,gBAAW,CAAA,CAAgB,EAAC,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,aAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,iCAAA,CAAA"}

package/lib/services/proxy-services/PostProxyService.d.ts

@@ -0,0 +1,42 @@
+import { ServiceBroker } from 'moleculer';
+import type { CdmLogger } from '@cdm-logger/core';
+import { IPostService } from 'common/server';
+/**
+ * Client-side proxy for Post operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IPostService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IPostService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles comprehensive post management within the messenger platform,
+ * providing operations for creating, updating, managing posts and their associated
+ * content including file attachments, notifications, threading, and real-time
+ * message delivery across channels and organizations through service broker delegation.
+ *
+ * Key capabilities:
+ * - Post lifecycle management (creation, updates, deletion)
+ * - File attachment handling and upload management
+ * - Real-time message delivery and notifications
+ * - Post threading and conversation management
+ * - Message status tracking (read, delivered)
+ * - Channel integration and message counting
+ * - Expo push notification integration
+ * - File upload link generation and management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IPostService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using PostServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see PostService for actual implementation
+ * @see PostMoleculerService for Moleculer service layer
+ */
+export declare class PostProxyService {
+    constructor(broker: ServiceBroker, logger: CdmLogger.ILogger);
+}
+export interface PostProxyService extends IPostService {
+}

package/lib/services/proxy-services/PostProxyService.js

@@ -0,0 +1,46 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {generateProxyMethods}from'@common-stack/codegen-zod';import {PostServiceSchemas}from'common/server';/**
+ * Client-side proxy for Post operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IPostService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IPostService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles comprehensive post management within the messenger platform,
+ * providing operations for creating, updating, managing posts and their associated
+ * content including file attachments, notifications, threading, and real-time
+ * message delivery across channels and organizations through service broker delegation.
+ *
+ * Key capabilities:
+ * - Post lifecycle management (creation, updates, deletion)
+ * - File attachment handling and upload management
+ * - Real-time message delivery and notifications
+ * - Post threading and conversation management
+ * - Message status tracking (read, delivered)
+ * - Channel integration and message counting
+ * - Expo push notification integration
+ * - File upload link generation and management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IPostService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using PostServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see PostService for actual implementation
+ * @see PostMoleculerService for Moleculer service layer
+ */
+let PostProxyService = class PostProxyService {
+  constructor(broker, logger) {
+    const childLogger = logger.child({
+      className: 'PostProxyService'
+    });
+    // ⚡ ONE LINE: Auto-generate all proxy methods
+    generateProxyMethods(this, PostServiceSchemas, broker, childLogger);
+  }
+};
+PostProxyService = __decorate([injectable()
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+, __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], PostProxyService);export{PostProxyService};//# sourceMappingURL=PostProxyService.js.map

package/lib/services/proxy-services/PostProxyService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostProxyService.js","sources":["../../../src/services/proxy-services/PostProxyService.ts"],"sourcesContent":[null],"names":[],"mappings":"0RAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AAGI,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB,CAAA;aACzB,CAAA,MAEI,EAAqB,MAErB,EAAyB;AAEzB,IAAA,MAAA,WAAM,GAAA,MAAc,CAAA,KAAO,CAAA;eAC3B,EAAA;;;IAGP,oBAAA,CAAA,IAAA,EAAA,kBAAA,EAAA,MAAA,EAAA,WAAA,CAAA;AAXY,EAAA;AAFZ;gBACD,GAAA,UAAA,CAAA,CAAA,UAAA;;AAGS,EAAA,OAAA,CAAA,CAAA,EAAA,iBAAO,CAAA,gBAAW,CAAA,CAAgB,EAAC,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,aAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,gBAAA,CAAA"}

package/lib/services/proxy-services/PostThreadProxyService.d.ts

@@ -0,0 +1,32 @@
+import { ServiceBroker } from 'moleculer';
+import type { CdmLogger } from '@cdm-logger/core';
+import { IPostThreadService } from 'common/server';
+/**
+ * Client-side proxy for PostThread operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IPostThreadService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IPostThreadService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles post thread management within the messenger platform,
+ * providing comprehensive operations for handling threaded conversations,
+ * reply management, and discussion organization across different channels
+ * and messaging contexts through service broker delegation.
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IPostThreadService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using PostThreadServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see PostThreadService for actual implementation
+ * @see PostThreadMoleculerService for Moleculer service layer
+ */
+export declare class PostThreadProxyService {
+    constructor(broker: ServiceBroker, logger: CdmLogger.ILogger);
+}
+export interface PostThreadProxyService extends IPostThreadService {
+}

package/lib/services/proxy-services/PostThreadProxyService.js

@@ -0,0 +1,36 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {generateProxyMethods}from'@common-stack/codegen-zod';import {PostThreadServiceSchemas}from'common/server';/**
+ * Client-side proxy for PostThread operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IPostThreadService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IPostThreadService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This microservice handles post thread management within the messenger platform,
+ * providing comprehensive operations for handling threaded conversations,
+ * reply management, and discussion organization across different channels
+ * and messaging contexts through service broker delegation.
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IPostThreadService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using PostThreadServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see PostThreadService for actual implementation
+ * @see PostThreadMoleculerService for Moleculer service layer
+ */
+let PostThreadProxyService = class PostThreadProxyService {
+  constructor(broker, logger) {
+    const childLogger = logger.child({
+      className: 'PostThreadProxyService'
+    });
+    // ⚡ ONE LINE: Auto-generate all proxy methods
+    generateProxyMethods(this, PostThreadServiceSchemas, broker, childLogger);
+  }
+};
+PostThreadProxyService = __decorate([injectable()
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+, __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], PostThreadProxyService);export{PostThreadProxyService};//# sourceMappingURL=PostThreadProxyService.js.map

package/lib/services/proxy-services/PostThreadProxyService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostThreadProxyService.js","sources":["../../../src/services/proxy-services/PostThreadProxyService.ts"],"sourcesContent":[null],"names":[],"mappings":"gSAOA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AAGI,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB,CAAA;aAC/B,CAAA,MAEI,EAAqB,MAErB,EAAyB;AAEzB,IAAA,MAAA,WAAM,GAAA,MAAc,CAAA,KAAO,CAAA;eAC3B,EAAA;;;IAGP,oBAAA,CAAA,IAAA,EAAA,wBAAA,EAAA,MAAA,EAAA,WAAA,CAAA;AAXY,EAAA;AAFZ;sBACD,GAAA,UAAA,CAAA,CAAA,UAAA;;AAGS,EAAA,OAAA,CAAA,CAAA,EAAA,iBAAO,CAAA,gBAAW,CAAA,CAAgB,EAAC,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,aAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,sBAAA,CAAA"}

package/lib/services/proxy-services/ReactionProxyService.d.ts

@@ -0,0 +1,41 @@
+import { ServiceBroker } from 'moleculer';
+import type { CdmLogger } from '@cdm-logger/core';
+import { IReactionService } from 'common/server';
+/**
+ * Client-side proxy for Reaction operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IReactionService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IReactionService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This service provides a comprehensive proxy layer for reaction management
+ * within the messenger platform, delegating operations to the reaction microservice
+ * while providing enhanced local functionality and error handling.
+ *
+ * Key capabilities:
+ * - Complete reaction lifecycle management (add, remove, update)
+ * - Content-based reaction retrieval and aggregation
+ * - User reaction tracking and analytics
+ * - Reaction statistics and trending analysis
+ * - Bulk reaction operations and content cleanup
+ * - Cross-platform reaction synchronization
+ * - Performance optimization through microservice delegation
+ * - Type-safe reaction data management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IReactionService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using ReactionServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see ReactionService for actual implementation
+ * @see ReactionMoleculerService for Moleculer service layer
+ */
+export declare class ReactionProxyService {
+    constructor(broker: ServiceBroker, logger: CdmLogger.ILogger);
+}
+export interface ReactionProxyService extends IReactionService {
+}

package/lib/services/proxy-services/ReactionProxyService.js

@@ -0,0 +1,45 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {generateProxyMethods}from'@common-stack/codegen-zod';import {ReactionServiceSchemas}from'common/server';/**
+ * Client-side proxy for Reaction operations using AUTO-GENERATION.
+ *
+ * 🎉 FULLY AUTOMATIC: All IReactionService methods auto-generated!
+ *
+ * ✅ ZERO BOILERPLATE: No manual method definitions
+ * ✅ TYPE-SAFE: Full TypeScript inference from IReactionService
+ * ✅ VALIDATED: Zod schemas for parameter validation
+ * ✅ MAINTAINABLE: Add method to interface → automatically available as proxy
+ *
+ * This service provides a comprehensive proxy layer for reaction management
+ * within the messenger platform, delegating operations to the reaction microservice
+ * while providing enhanced local functionality and error handling.
+ *
+ * Key capabilities:
+ * - Complete reaction lifecycle management (add, remove, update)
+ * - Content-based reaction retrieval and aggregation
+ * - User reaction tracking and analytics
+ * - Reaction statistics and trending analysis
+ * - Bulk reaction operations and content cleanup
+ * - Cross-platform reaction synchronization
+ * - Performance optimization through microservice delegation
+ * - Type-safe reaction data management
+ *
+ * Pattern:
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - All IReactionService methods are automatically generated as Moleculer action calls
+ * - Parameters are validated using ReactionServiceSchemas
+ * - Topic is automatically extracted from schemas
+ *
+ * @see ReactionService for actual implementation
+ * @see ReactionMoleculerService for Moleculer service layer
+ */
+let ReactionProxyService = class ReactionProxyService {
+  constructor(broker, logger) {
+    const childLogger = logger.child({
+      className: 'ReactionProxyService'
+    });
+    // ⚡ ONE LINE: Auto-generate all proxy methods
+    generateProxyMethods(this, ReactionServiceSchemas, broker, childLogger);
+  }
+};
+ReactionProxyService = __decorate([injectable()
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+, __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], ReactionProxyService);export{ReactionProxyService};//# sourceMappingURL=ReactionProxyService.js.map

package/lib/services/proxy-services/ReactionProxyService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactionProxyService.js","sources":["../../../src/services/proxy-services/ReactionProxyService.ts"],"sourcesContent":[null],"names":[],"mappings":"8RAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AAGI,IAAM,oBAAoB,GAA1B,MAAM,oBAAoB,CAAA;aAC7B,CAAA,MAEI,EAAqB,MAErB,EAAyB;AAEzB,IAAA,MAAA,WAAM,GAAA,MAAc,CAAA,KAAO,CAAA;eAC3B,EAAA;;;IAGP,oBAAA,CAAA,IAAA,EAAA,sBAAA,EAAA,MAAA,EAAA,WAAA,CAAA;AAXY,EAAA;AAFZ;oBACD,GAAA,UAAA,CAAA,CAAA,UAAA;;AAGS,EAAA,OAAA,CAAA,CAAA,EAAA,iBAAO,CAAA,gBAAW,CAAA,CAAgB,EAAC,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,aAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,oBAAA,CAAA"}

package/lib/services/proxy-services/index.d.ts

@@ -1,5 +1,17 @@
-export * from './channel-microservice';
-export * from './post-thread-microservice';
-export * from './post-microservice';
-export * from './reaction-microservice';
-export * from './messenger-notification-microservice';
+/**
+ * Proxy Services Index
+ *
+ * All proxy services use the modern auto-generation pattern (Pattern 1):
+ * - Uses generateProxyMethods() from @common-stack/codegen-zod
+ * - Declaration merging for type safety
+ * - Zero boilerplate - all methods auto-generated
+ * - Topic automatically extracted from ServiceSchemas
+ *
+ * @see LLM Proxy Service Generator Prompt for implementation guidelines
+ */
+export * from './ChannelProxyService';
+export * from './ExtendedTokenAccountProxyService';
+export * from './PostProxyService';
+export * from './PostThreadProxyService';
+export * from './ReactionProxyService';
+export * from './MessengerNotificationProxyService';

package/lib/services/reaction-service.d.ts

@@ -1,6 +1,126 @@
-import { IReaction, IReactionInput, IReactionRepository, IReactionService, IReactionServiceInput } from 'common';
-import { BaseService } from '@common-stack/store-mongo';
-export declare class ReactionService extends BaseService<IReaction, IReactionServiceInput, Partial<IReactionInput>> implements IReactionService {
+import { IReactionModel, IReactionInput, IReactionRepository, IReactionService, IReactionServiceInput, AsDomainType } from 'common/server';
+import { BaseService2 } from '@common-stack/store-mongo';
+import { CdmLogger } from '@cdm-logger/core';
+import { Disposable, DisposableCollection } from '@adminide-stack/core';
+/**
+ * Reaction Service Implementation
+ *
+ * This service handles reaction management within the messenger platform,
+ * providing comprehensive operations for handling emoji reactions, sentiment
+ * tracking, and user engagement features across posts, messages, and other
+ * interactive content.
+ */
+export declare class ReactionService extends BaseService2<IReactionModel, IReactionServiceInput, Partial<IReactionInput>> implements IReactionService, Disposable {
     readonly reactionRepository: IReactionRepository;
-    constructor(reactionRepository: IReactionRepository);
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(reactionRepository: IReactionRepository, logger?: CdmLogger.ILogger);
+    /**
+     * Disposes of resources used by the service
+     */
+    dispose(): void;
+    /**
+     * Adds a reaction to a post or message
+     *
+     * @description Creates a new reaction entry for a specific content item,
+     * handling duplicate detection and user validation.
+     *
+     * @param {IReactionServiceInput} data - Reaction creation data including user and reaction type
+     * @returns {Promise<AsDomainType<IReactionModel> | Error>} - Created reaction or error
+     */
+    addReaction(data: IReactionServiceInput): Promise<AsDomainType<IReactionModel> | Error>;
+    /**
+     * Removes a reaction from a post or message
+     *
+     * @description Deletes an existing reaction entry, ensuring proper user
+     * authorization and content validation.
+     *
+     * @param {string} reactionId - The unique identifier of the reaction to remove
+     * @param {string} userId - The identifier of the user removing the reaction
+     * @returns {Promise<boolean | Error>} - Success status or error
+     */
+    removeReaction(reactionId: string, userId: string): Promise<boolean | Error>;
+    /**
+     * Retrieves all reactions for a specific content item
+     *
+     * @description Fetches reaction data with aggregation and user information
+     * for display in the user interface.
+     *
+     * @param {string} contentId - The identifier of the content (post, message, etc.)
+     * @param {string} contentType - The type of content being reacted to
+     * @returns {Promise<Array<AsDomainType<IReactionModel>> | Error>} - Array of reactions or error
+     */
+    getReactionsByContent(contentId: string, contentType: string): Promise<Array<AsDomainType<IReactionModel>> | Error>;
+    /**
+     * Retrieves reaction statistics for content
+     *
+     * @description Provides aggregated reaction counts and statistics
+     * for analytics and display purposes.
+     *
+     * @param {string} contentId - The identifier of the content
+     * @param {string} contentType - The type of content
+     * @returns {Promise<any | Error>} - Reaction statistics or error
+     */
+    getReactionStats(contentId: string, contentType: string): Promise<any | Error>;
+    /**
+     * Checks if a user has reacted to specific content
+     *
+     * @description Determines whether a user has already reacted to
+     * a piece of content, useful for UI state management.
+     *
+     * @param {string} contentId - The identifier of the content
+     * @param {string} userId - The identifier of the user
+     * @param {string} reactionType - The type of reaction to check
+     * @returns {Promise<boolean | Error>} - True if user has reacted, or error
+     */
+    hasUserReacted(contentId: string, userId: string, reactionType: string): Promise<boolean | Error>;
+    /**
+     * Updates an existing reaction
+     *
+     * @description Modifies an existing reaction, typically changing
+     * the reaction type while maintaining the same user and content association.
+     *
+     * @param {string} reactionId - The unique identifier of the reaction
+     * @param {Partial<IReactionInput>} updates - The reaction updates to apply
+     * @returns {Promise<AsDomainType<IReactionModel> | Error>} - Updated reaction or error
+     */
+    updateReaction(reactionId: string, updates: Partial<IReactionInput>): Promise<AsDomainType<IReactionModel> | Error>;
+    /**
+     * Removes all reactions from specific content
+     *
+     * @description Bulk removes all reactions from a content item,
+     * typically used during content deletion or moderation.
+     *
+     * @param {string} contentId - The identifier of the content
+     * @param {string} contentType - The type of content
+     * @returns {Promise<number | Error>} - Number of reactions removed or error
+     */
+    removeAllReactionsByContent(contentId: string, contentType: string): Promise<number | Error>;
+    /**
+     * Retrieves reactions by user across all content
+     *
+     * @description Gets all reactions created by a specific user,
+     * useful for user activity tracking and analytics.
+     *
+     * @param {string} userId - The identifier of the user
+     * @param {number} limit - Maximum number of reactions to return
+     * @param {number} offset - Number of reactions to skip
+     * @returns {Promise<Array<AsDomainType<IReactionModel>> | Error>} - Array of user reactions or error
+     */
+    getUserReactions(userId: string, limit?: number, offset?: number): Promise<Array<AsDomainType<IReactionModel>> | Error>;
+    /**
+     * Gets the most popular reactions across the platform
+     *
+     * @description Retrieves aggregated data about the most used reactions
+     * for analytics and trending features.
+     *
+     * @param {number} limit - Maximum number of popular reactions to return
+     * @param {Date} since - Optional date to filter reactions since
+     * @returns {Promise<Array<{ type: string; count: number; users: number }> | Error>} - Popular reactions or error
+     */
+    getPopularReactions(limit?: number, since?: Date): Promise<Array<{
+        type: string;
+        count: number;
+        users: number;
+    }> | Error>;
 }