@wabot-dev/framework 0.0.6 → 0.0.8

package/dist/src/index.d.ts

@@ -1,111 +1,9 @@
+import InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
+import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
+import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
 import * as tsyringe from 'tsyringe';
-import { DependencyContainer, InjectionToken } from 'tsyringe';
+import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
-import { InterceptionOptions } from 'tsyringe/dist/typings/types';
-import { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
-
-interface IChatDocument {
-}
-
-interface IChatImage {
-}
-
-interface IChatSender {
-    shortName: string;
-    senderId?: string;
-}
-
-interface IChatMessage {
-    sender: IChatSender;
-    text?: string;
-    documents?: IChatDocument[];
-    images?: IChatImage[];
-}
-
-interface IChatFunctionCall {
-    foreignId: string;
-    name: string;
-    arguments?: string;
-    result: string;
-}
-
-type ISystemMessageItem = {
-    type: 'BOT_MESSAGE';
-    content: IChatMessage;
-};
-type IUserMessageItem = {
-    type: 'USER_MESSAGE';
-    content: IChatMessage;
-};
-type ISystemFunctionCallItem = {
-    type: 'FUNCTION_CALL';
-    content: IChatFunctionCall;
-};
-type IChatItem = {
-    id: string;
-    createdAt: Date;
-} & (ISystemMessageItem | IUserMessageItem | ISystemFunctionCallItem);
-type IChatItemType = IChatItem['type'];
-
-interface IChatMemory {
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
-}
-declare class ChatMemory implements IChatMemory {
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
-}
-
-declare class RamChatMemory implements IChatMemory {
-    private memory;
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
-    clearMemory(): Promise<void>;
-}
-
-type IChatType = 'PRIVATE' | 'GROUP';
-interface IChatConnection {
-    channelType: string;
-    chatId: string;
-}
-interface IChatData {
-    id?: string;
-    createdAt?: Date;
-    type: IChatType;
-    connections: IChatConnection[];
-}
-declare class Chat {
-    private data;
-    constructor(data: IChatData);
-    isPrivate(): boolean;
-    isGroup(): boolean;
-    hasConnection(connection: IChatConnection): boolean;
-    private validatePrivateChat;
-    private validateGroupChat;
-    getId(): string;
-    wasCreated(): boolean;
-    validate(): void;
-}
-
-interface IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-}
-declare class ChatRepository implements IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-}
-
-declare class RamChatRepository implements IChatRepository {
-    private items;
-    private memories;
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-    private getMemory;
-}
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -159,6 +57,7 @@ interface IMindsetDecoration {
 
 interface IMindsetModuleConfig {
     description: string;
+    language?: string;
 }
 
 declare function mindsetModule<A>(config: IMindsetModuleConfig): (target: IConstructor<A>) => void;
@@ -188,6 +87,9 @@ interface IParamDecoration {
     decorationConfig: any;
 }
 
+declare const PARAM_DECORATION_IS_OPTIONAL = "isOptional";
+declare const PARAM_DECORATION_PARAM = "param";
+
 interface IMindsetFunctionParamMetadata {
     config: IParamConfig;
     name: string;
@@ -284,6 +186,165 @@ declare class ChatBotMetadataStore {
     getChatBotsMetadata(): IChatBotMetadata[];
 }
 
+type IChatType = 'PRIVATE' | 'GROUP';
+interface IChatConnection {
+    chatType: IChatType;
+    channelName: string;
+    id: string;
+}
+interface IChatData {
+    id?: string;
+    createdAt?: Date;
+    type: IChatType;
+    connections: IChatConnection[];
+}
+declare class Chat {
+    private data;
+    constructor(data: IChatData);
+    isPrivate(): boolean;
+    isGroup(): boolean;
+    hasConnection(connection: IChatConnection): boolean;
+    private validatePrivateChat;
+    private validateGroupChat;
+    getId(): string;
+    wasCreated(): boolean;
+    validate(): void;
+}
+
+interface IChatDocument {
+}
+
+interface IChatImage {
+}
+
+interface IUserConnection {
+    channelName: string;
+    id: string;
+}
+interface IUserData {
+    id?: string;
+    createdAt?: Date;
+    shortName: string;
+    connections: IUserConnection[];
+    keyValueData: {
+        [key: string]: string;
+    };
+}
+declare class User {
+    private data;
+    constructor(data: IUserData);
+    getId(): string;
+    hasConnection(connection: IUserConnection): boolean;
+    wasCreated(): boolean;
+    validate(): void;
+    getValue(key: string): string;
+    setValue(key: string, value: string): void;
+    addConnection(connection: IUserConnection): void;
+}
+
+interface IChatMessage {
+    text?: string;
+    documents?: IChatDocument[];
+    images?: IChatImage[];
+    senderName: string;
+}
+interface IConnectionChatMessage extends IChatMessage {
+    chatConnection: IChatConnection;
+    userConnection: IUserConnection;
+    userId?: string;
+}
+
+interface IChatFunctionCall {
+    id: string;
+    name: string;
+    arguments?: string;
+    result: string;
+}
+
+type ISystemMessageItem = {
+    type: 'BOT_MESSAGE';
+    content: IChatMessage;
+};
+type IReceivedMessageItem = {
+    type: 'CONNECTION_MESSAGE';
+    content: IConnectionChatMessage;
+};
+type ISystemFunctionCallItem = {
+    type: 'FUNCTION_CALL';
+    content: IChatFunctionCall;
+};
+type IChatItem = {
+    id: string;
+    createdAt: Date;
+} & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
+type IChatItemType = IChatItem['type'];
+
+interface IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}
+declare class ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}
+
+declare class RamChatMemory implements IChatMemory {
+    private memory;
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+    clearMemory(): Promise<void>;
+}
+
+interface IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+declare class ChatRepository implements IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+
+declare class RamChatRepository implements IChatRepository {
+    private items;
+    private memories;
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+    private getMemory;
+}
+
+interface IUserRepository {
+    create(chat: User): Promise<void>;
+    update(chat: User): Promise<void>;
+    findByConnection(query: IUserConnection): Promise<User | null>;
+}
+declare class UserRepository implements IUserRepository {
+    create(chat: User): Promise<void>;
+    update(chat: User): Promise<void>;
+    findByConnection(query: IUserConnection): Promise<User | null>;
+}
+
+declare class RamUserRepository implements IUserRepository {
+    private items;
+    create(chat: User): Promise<void>;
+    findByConnection(query: IUserConnection): Promise<User | null>;
+    update(chat: User): Promise<void>;
+}
+
+interface IMessageContext {
+    message: IConnectionChatMessage;
+    chat: Chat;
+    user: User | null;
+}
+declare class MessageContext implements IMessageContext {
+    message: IConnectionChatMessage;
+    chat: Chat;
+    user: User | null;
+    constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
+}
+
 interface IChatBotAdapter {
     generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
 }
@@ -296,12 +357,12 @@ declare class ChatBotAdapter implements IChatBotAdapter {
         id: string;
         createdAt: Date;
     } & ISystemMessageItem>;
-    protected buildFunctionCallItem(foreignId: string, functionName: string, functionArguments: string): Promise<{
+    protected buildFunctionCallItem(id: string, functionName: string, functionArguments: string): Promise<{
         readonly id: string;
         readonly createdAt: Date;
         readonly type: "FUNCTION_CALL";
         readonly content: {
-            readonly foreignId: string;
+            readonly id: string;
             readonly name: string;
             readonly arguments: string;
             readonly result: string;
@@ -317,7 +378,7 @@ declare class ChatBot implements IChatBot {
     private memory;
     private adapter;
     constructor(memory: ChatMemory, adapter: ChatBotAdapter);
-    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
+    sendMessage(message: IConnectionChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
     protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
 }
 
@@ -331,46 +392,28 @@ declare class OpenaiChatBotAdapter extends ChatBotAdapter {
 
 declare function cmd(): (target: object, propertyKey: string | symbol) => void;
 
-interface IChatContext {
-    chatId: string;
-    message: IChatMessage;
-    reply: (message: IChatMessage) => void;
-}
-interface IUserContext {
-    userId: string;
-}
-interface IContext {
-    user?: IUserContext;
-    chat: IChatContext;
-}
-declare class Context implements IContext {
-    chat: IChatContext;
-    user?: IUserContext | undefined;
-    constructor(chat: IChatContext, user?: IUserContext | undefined);
-}
-
-interface IMessageOrigin {
-    chatId: string;
-    chatType: IChatType;
-    channelType: Function;
-}
-interface IMessageContext extends IChatContext {
-    origin: IMessageOrigin;
-}
-
 declare class ChatResolver {
     private chatRepository;
     constructor(chatRepository: ChatRepository);
-    resolve(origin: IMessageOrigin): Promise<Chat>;
+    resolve(connection: IChatConnection): Promise<Chat>;
     private resolveGroupChat;
     private resolvePrivateChat;
 }
 
+interface IReceivedMessage extends IMessageContext {
+    reply: (message: IChatMessage) => void;
+}
 interface IChatChannel {
-    listen(callback: (message: IMessageContext) => void): void;
+    listen(callback: (message: IReceivedMessage) => void): void;
     connect(): void;
 }
 
+declare class UserResolver {
+    private userRepository;
+    constructor(userRepository: UserRepository);
+    resolve(connection: IUserConnection): Promise<User | null>;
+}
+
 interface IchatControllerConfig {
 }
 
@@ -400,10 +443,11 @@ declare class ControllerMetadataStore {
 
 declare class CmdChannel implements IChatChannel {
     private chatResolver;
+    private userResolver;
     private rl;
     private callBack;
-    constructor(chatResolver: ChatResolver);
-    listen(callback: (message: IMessageContext) => void): void;
+    constructor(chatResolver: ChatResolver, userResolver: UserResolver);
+    listen(callback: (message: IReceivedMessage) => void): void;
     connect(): void;
 }
 
@@ -420,13 +464,14 @@ declare function telegram(config: ITelegramChannelConfig): (target: object, prop
 declare class TelegramChannel implements IChatChannel {
     private config;
     private chatResolver;
+    private userResolver;
     private bot;
-    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver);
-    listen(callback: (message: IMessageContext) => void): void;
+    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver);
+    listen(callback: (message: IReceivedMessage) => void): void;
     connect(): void;
 }
 
-declare function prepareChatContainer(container: DependencyContainer, context: IContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer>;
+declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
 
 interface IrunChannelProps {
     channel: IConstructor<IChatChannel>;
@@ -437,11 +482,69 @@ interface IrunChannelProps {
 }
 declare function runChannel(props: IrunChannelProps): void;
 
+interface IServerProvider<T, ST extends T> {
+    replace: IConstructor<T>;
+    with: IConstructor<ST>;
+    singleton?: true;
+}
 interface IServerConfig {
     controllers: IConstructor<any>[];
-    chatRepository?: IConstructor<IChatRepository>;
-    chatBotAdapter?: IConstructor<IChatBotAdapter>;
+    providers?: IServerProvider<unknown, unknown>[];
 }
 declare function runServer(config: IServerConfig): void;
 
-export { Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, Context, ControllerMetadataStore, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatContext, type IChatControllerMetadata, type IChatData, type IChatDocument, type IChatFunctionCall, type IChatImage, type IChatItem, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatSender, type IChatType, type IConstructor, type IContext, type IMessageContext, type IMessageOrigin, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IParamDecoration, type IServerConfig, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserContext, type IUserMessageItem, type IchatControllerConfig, type IrunChannelProps, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, RamChatMemory, RamChatRepository, TelegramChannel, TelegramChannelConfig, chatBot, chatController, cmd, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, telegram };
+declare class SendOneTimePasswordRequest {
+    fromEmail: string;
+    toEmail: string;
+}
+
+declare class ValidateOneTimePasswordRequest {
+    userEmail: string;
+    otp: string;
+}
+
+interface ISendEmailRequest {
+    from: string;
+    to: string;
+    subject: string;
+    html: string;
+}
+interface IEmailService {
+    sendEmail(request: ISendEmailRequest): Promise<void>;
+}
+declare class EmailService implements IEmailService {
+    sendEmail(request: ISendEmailRequest): Promise<void>;
+}
+
+interface IOtpService {
+    generate(): Promise<string>;
+}
+declare class OtpService implements IOtpService {
+    generate(): Promise<string>;
+}
+
+declare class AuthenticationModule {
+    private userRepository;
+    private emailService;
+    private otpService;
+    private context;
+    constructor(userRepository: UserRepository, emailService: EmailService, otpService: OtpService, context: MessageContext);
+    sendOneTimePassword(request: SendOneTimePasswordRequest): Promise<string>;
+    validateOneTimePassword(request: ValidateOneTimePasswordRequest): Promise<string>;
+    protected generateOtpEmailHtml(otp: string, user: User): Promise<string>;
+    protected generateOtpEmailSubject(): Promise<string>;
+}
+
+declare class RegisterUserWithEmailRequest {
+    email: string;
+    shortName: string;
+}
+
+declare class RegisterUserModule {
+    private userRepository;
+    private context;
+    constructor(userRepository: UserRepository, context: MessageContext);
+    registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
+}
+
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, EmailService, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItem, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type IEmailService, type IMessageContext, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IReceivedMessage, type IReceivedMessageItem, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IchatControllerConfig, type IrunChannelProps, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, chatBot, chatController, cmd, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, telegram };

package/dist/src/index.js

@@ -4,20 +4,8 @@ export { CmdChannel } from './channels/cmd/CmdChannel.js';
 export { telegram } from './channels/telegram/@telegram.js';
 export { TelegramChannelConfig } from './channels/telegram/TelegramChannelConfig.js';
 export { TelegramChannel } from './channels/telegram/TelegramChannel.js';
-export { RamChatMemory } from './chatbot/chat/repository/ram/RamChatMemory.js';
-export { RamChatRepository } from './chatbot/chat/repository/ram/RamChatRepository.js';
-export { ChatMemory } from './chatbot/chat/repository/IChatMemory.js';
-export { ChatRepository } from './chatbot/chat/repository/IChatRepository.js';
-export { Chat } from './chatbot/chat/Chat.js';
 export { chatBot } from './chatbot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './chatbot/metadata/ChatBotMetadataStore.js';
-export { ChatBot } from './chatbot/ChatBot.js';
-export { ChatBotAdapter } from './chatbot/ChatBotAdapter.js';
-export { Context } from './context/IContext.js';
-export { ChatResolver } from './controller/channel/ChatResolver.js';
-export { chatController } from './controller/metadata/controller/@chatController.js';
-export { ControllerMetadataStore } from './controller/metadata/ControllerMetadataStore.js';
-export { container, inject, injectable, singleton } from './injection/index.js';
 export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.js';
 export { MINDSET_FUNCTION_DECORATION_FUNCTION } from './mindset/metadata/functions/decoratorNames.js';
 export { mindset } from './mindset/metadata/mindsets/@mindset.js';
@@ -26,10 +14,34 @@ export { mindsetModule } from './mindset/metadata/modules/@mindsetModule.js';
 export { MINDSET_MODULE_DECORATION_MODULE } from './mindset/metadata/modules/decoratorNames.js';
 export { isOptional } from './mindset/metadata/params/@isOptional.js';
 export { param } from './mindset/metadata/params/@param.js';
-export { MindsetMetadataStore } from './mindset/metadata/MindsetMetadataStore.js';
+export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM } from './mindset/metadata/params/decoratorNames.js';
 export { Mindset } from './mindset/IMindset.js';
+export { MindsetMetadataStore } from './mindset/metadata/MindsetMetadataStore.js';
 export { MindsetOperator } from './mindset/MindsetOperator.js';
+export { ChatBot } from './chatbot/ChatBot.js';
+export { ChatBotAdapter } from './chatbot/ChatBotAdapter.js';
+export { RamChatMemory } from './core/chat/repository/ram/RamChatMemory.js';
+export { RamChatRepository } from './core/chat/repository/ram/RamChatRepository.js';
+export { ChatMemory } from './core/chat/repository/IChatMemory.js';
+export { ChatRepository } from './core/chat/repository/IChatRepository.js';
+export { Chat } from './core/chat/Chat.js';
+export { User } from './core/user/User.js';
+export { RamUserRepository } from './core/user/repository/ram/RamUserRepository.js';
+export { UserRepository } from './core/user/repository/IUserRepository.js';
+export { MessageContext } from './core/IMessageContext.js';
+export { ChatResolver } from './controller/channel/ChatResolver.js';
+export { UserResolver } from './controller/channel/UserResolver.js';
+export { chatController } from './controller/metadata/controller/@chatController.js';
+export { ControllerMetadataStore } from './controller/metadata/ControllerMetadataStore.js';
+export { container, inject, injectable, singleton } from './injection/index.js';
 export { prepareChatContainer } from './server/prepareChatContainer.js';
 export { runChannel } from './server/runChannel.js';
 export { runServer } from './server/runServer.js';
+export { SendOneTimePasswordRequest } from './pre-made/modules/authentication/requests/SendOneTimePasswordRequest.js';
+export { ValidateOneTimePasswordRequest } from './pre-made/modules/authentication/requests/ValidateOneTimePasswordRequest.js';
+export { AuthenticationModule } from './pre-made/modules/authentication/AuthenticationModule.js';
+export { RegisterUserWithEmailRequest } from './pre-made/modules/register-user/requests/RegisterUserWithEmailRequest.js';
+export { RegisterUserModule } from './pre-made/modules/register-user/RegisterUserModule.js';
+export { EmailService } from './pre-made/services/EmailService.js';
+export { OtpService } from './pre-made/services/OtpService.js';
 export { Container } from './injection/Container.js';

package/dist/src/mindset/IMindset.js

@@ -1,12 +1,12 @@
 class Mindset {
     identity() {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     skills() {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     limits() {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 }
 

package/dist/src/mindset/metadata/params/@isOptional.js

@@ -13,7 +13,7 @@ function isOptional() {
             paramType: paramType,
             paramName: paramName,
             constructor: target.constructor,
-            decorationConfig: {}
+            decorationConfig: {},
         });
     };
 }

package/dist/src/pre-made/modules/authentication/AuthenticationModule.js

@@ -0,0 +1,99 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../core/chat/repository/ram/RamChatRepository.js';
+import '../../../core/chat/repository/IChatRepository.js';
+import '../../../core/user/repository/ram/RamUserRepository.js';
+import { UserRepository } from '../../../core/user/repository/IUserRepository.js';
+import { MessageContext } from '../../../core/IMessageContext.js';
+import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
+import 'reflect-metadata';
+import '../../../injection/index.js';
+import '../../../mindset/metadata/MindsetMetadataStore.js';
+import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
+import '../../../mindset/MindsetOperator.js';
+import { EmailService } from '../../services/EmailService.js';
+import { OtpService } from '../../services/OtpService.js';
+import { SendOneTimePasswordRequest } from './requests/SendOneTimePasswordRequest.js';
+import { ValidateOneTimePasswordRequest } from './requests/ValidateOneTimePasswordRequest.js';
+
+let AuthenticationModule = class AuthenticationModule {
+    userRepository;
+    emailService;
+    otpService;
+    context;
+    constructor(userRepository, emailService, otpService, context) {
+        this.userRepository = userRepository;
+        this.emailService = emailService;
+        this.otpService = otpService;
+        this.context = context;
+    }
+    async sendOneTimePassword(request) {
+        const user = await this.userRepository.findByConnection({
+            channelName: 'EmailChannel',
+            id: request.toEmail,
+        });
+        if (!user)
+            return 'success';
+        const otp = await this.otpService.generate();
+        const html = await this.generateOtpEmailHtml(otp, user);
+        const subject = await this.generateOtpEmailSubject();
+        await this.emailService.sendEmail({
+            from: request.fromEmail,
+            to: request.toEmail,
+            subject,
+            html,
+        });
+        user.setValue('OTP', otp);
+        await this.userRepository.update(user);
+        return 'success';
+    }
+    async validateOneTimePassword(request) {
+        const user = await this.userRepository.findByConnection({
+            channelName: 'EmailChannel',
+            id: request.userEmail,
+        });
+        if (!user) {
+            throw new Error('Invalid OTP');
+        }
+        const otp = user.getValue('OTP');
+        if (otp !== request.otp) {
+            throw new Error('Invalid OTP');
+        }
+        user.addConnection(this.context.message.userConnection);
+        await this.userRepository.update(user);
+        return 'success';
+    }
+    async generateOtpEmailHtml(otp, user) {
+        return `<p>Your OTP Code is ${otp}</p>`;
+    }
+    async generateOtpEmailSubject() {
+        return 'OTP Code';
+    }
+};
+__decorate([
+    mindsetFunction({
+        description: 'Send an One Time Password to the user when want authenticate',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [SendOneTimePasswordRequest]),
+    __metadata("design:returntype", Promise)
+], AuthenticationModule.prototype, "sendOneTimePassword", null);
+__decorate([
+    mindsetFunction({
+        description: 'Send an One Time Password to the user when want authenticate',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ValidateOneTimePasswordRequest]),
+    __metadata("design:returntype", Promise)
+], AuthenticationModule.prototype, "validateOneTimePassword", null);
+AuthenticationModule = __decorate([
+    mindsetModule({
+        description: 'Provide authentication methods',
+        language: 'english',
+    }),
+    __metadata("design:paramtypes", [UserRepository,
+        EmailService,
+        OtpService,
+        MessageContext])
+], AuthenticationModule);
+
+export { AuthenticationModule };