@wabot-dev/framework 0.1.0-beta.6 → 0.1.0-beta.60

package/dist/src/pre-made/module/register-user/RegisterUserModule.js

@@ -1,56 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../core/user/User.js';
-import { UserRepository } from '../../../core/user/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 { RegisterUserWithEmailRequest } from './requests/RegisterUserWithEmailRequest.js';
-
-let RegisterUserModule = class RegisterUserModule {
-    userRepository;
-    context;
-    constructor(userRepository, context) {
-        this.userRepository = userRepository;
-        this.context = context;
-    }
-    async registerUserWithEmail(request) {
-        if (this.context.user) {
-            throw new Error('The User is already authenticated');
-        }
-        const user = new User({
-            shortName: request.shortName,
-            connections: [
-                {
-                    channelName: 'EmailChannel',
-                    id: request.email,
-                },
-            ],
-            keyValueData: {},
-        });
-        await this.userRepository.create(user);
-        return 'success';
-    }
-};
-__decorate([
-    mindsetFunction({
-        description: 'Register a new user using email',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [RegisterUserWithEmailRequest]),
-    __metadata("design:returntype", Promise)
-], RegisterUserModule.prototype, "registerUserWithEmail", null);
-RegisterUserModule = __decorate([
-    mindsetModule({
-        description: 'Provide functions to register an user',
-        language: 'english',
-    }),
-    __metadata("design:paramtypes", [UserRepository,
-        MessageContext])
-], RegisterUserModule);
-
-export { RegisterUserModule };

package/dist/src/pre-made/module/register-user/requests/RegisterUserWithEmailRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class RegisterUserWithEmailRequest {
-    email = '';
-    shortName = '';
-}
-__decorate([
-    param({
-        description: 'Email of the User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "email", void 0);
-__decorate([
-    param({
-        description: 'ShortName for the new User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "shortName", void 0);
-
-export { RegisterUserWithEmailRequest };

package/dist/src/pre-made/repository/user/pg/PgUserRepository.js

@@ -1,33 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../../core/user/User.js';
-import '../../../../core/user/IUserRepository.js';
-import { singleton } from '../../../../injection/index.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import { Pool } from 'pg';
-
-let PgUserRepository = class PgUserRepository extends PgCrudRepository {
-    constructor(pool) {
-        super(pool, {
-            table: 'user',
-            schema: 'wabot',
-            constructor: User,
-        });
-    }
-    async findByConnection(query) {
-        const sql = `
-      SELECT ${this.columns}
-      FROM ${this.table}
-      WHERE data->'connections' @> $1::jsonb
-      LIMIT 1
-    `;
-        const items = await this.query(sql, [JSON.stringify([query])]);
-        return items.at(0) ?? null;
-    }
-};
-PgUserRepository = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Pool])
-], PgUserRepository);
-
-export { PgUserRepository };

package/dist/src/pre-made/repository/user/ram/RamUserRepository.js

@@ -1,27 +0,0 @@
-import { __decorate } from 'tslib';
-import { v4 } from 'uuid';
-import { singleton } from '../../../../injection/index.js';
-
-let RamUserRepository = class RamUserRepository {
-    items = [];
-    async create(chat) {
-        if (chat.wasCreated()) {
-            throw new Error('User already created');
-        }
-        chat['data'].id = v4();
-        chat['data'].createdAt = new Date().getTime();
-        chat.validate();
-        this.items.push(chat);
-    }
-    async findByConnection(query) {
-        return this.items.find((item) => item.hasConnection(query)) ?? null;
-    }
-    async update(chat) {
-        // TODO
-    }
-};
-RamUserRepository = __decorate([
-    singleton()
-], RamUserRepository);
-
-export { RamUserRepository };

package/dist/src/pre-made/service/EmailService.js

@@ -1,13 +0,0 @@
-import { __decorate } from 'tslib';
-import { injectable } from '../../injection/index.js';
-
-let EmailService = class EmailService {
-    async sendEmail(request) {
-        throw new Error('Not implemented');
-    }
-};
-EmailService = __decorate([
-    injectable()
-], EmailService);
-
-export { EmailService };

package/dist/src/pre-made/service/OtpService.js

@@ -1,14 +0,0 @@
-import { __decorate } from 'tslib';
-import { injectable } from '../../injection/index.js';
-import { randomInt } from 'crypto';
-
-let OtpService = class OtpService {
-    async generate() {
-        return randomInt(100000, 999999).toString();
-    }
-};
-OtpService = __decorate([
-    injectable()
-], OtpService);
-
-export { OtpService };

package/dist/src/server/prepareChatContainer.js

@@ -1,43 +0,0 @@
-import '../injection/index.js';
-import 'reflect-metadata';
-import '../mindset/metadata/MindsetMetadataStore.js';
-import { Mindset } from '../mindset/IMindset.js';
-import '../mindset/MindsetOperator.js';
-import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import { MessageContext } from '../core/IMessageContext.js';
-import 'uuid';
-import { ChatBotMetadataStore } from '../chatbot/metadata/ChatBotMetadataStore.js';
-import { ChatBot } from '../chatbot/ChatBot.js';
-import { Container } from '../injection/Container.js';
-
-async function prepareChatContainer(container, context, mindsetCtor) {
-    const chatContainer = container.createChildContainer();
-    chatContainer.register(Container, { useValue: chatContainer });
-    chatContainer.register(MessageContext, {
-        useValue: new MessageContext(context.message, context.chat, context.user),
-    });
-    const chatRepository = container.resolve(ChatRepository);
-    const chatMemory = await chatRepository.findMemory(context.chat.getId());
-    if (!chatMemory) {
-        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.getId());
-    }
-    chatContainer.register(ChatMemory, { useValue: chatMemory });
-    const chatBotMetadataStore = container.resolve(ChatBotMetadataStore);
-    const chatBots = chatBotMetadataStore.getChatBotsMetadata();
-    for (const chatBotMetadata of chatBots) {
-        chatContainer.beforeResolution(chatBotMetadata.constructor, (a, b) => {
-            const subContainer = chatContainer.createChildContainer();
-            subContainer.register(Mindset, { useClass: chatBotMetadata.mindsetConstructor });
-            const chatBot = subContainer.resolve(ChatBot);
-            chatContainer.register(chatBotMetadata.injectionToken, { useValue: chatBot });
-        });
-    }
-    if (mindsetCtor) {
-        chatContainer.register(Mindset, { useClass: mindsetCtor });
-    }
-    return chatContainer;
-}
-
-export { prepareChatContainer };

package/dist/src/server/runChannel.js

@@ -1,27 +0,0 @@
-import { container } from '../injection/index.js';
-import 'uuid';
-import '../chatbot/metadata/ChatBotMetadataStore.js';
-import { ChatBot } from '../chatbot/ChatBot.js';
-import { ChatBotAdapter } from '../chatbot/ChatBotAdapter.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import { prepareChatContainer } from './prepareChatContainer.js';
-
-function runChannel(props) {
-    container.registerSingleton(ChatRepository, props.chatRepository);
-    container.register(ChatBotAdapter, { useClass: props.chatBotAdapter });
-    if (props.channelConfig) {
-        container.register(props.channelConfig.constructor, { useValue: props.channelConfig });
-    }
-    const channel = container.resolve(props.channel);
-    channel.listen(async (context) => {
-        const channelContainer = await prepareChatContainer(container, context, props.mindset);
-        const chatBot = channelContainer.resolve(ChatBot);
-        chatBot.sendMessage(context.message, (replyMessage) => {
-            context.reply(replyMessage);
-        });
-    });
-    channel.connect();
-}
-
-export { runChannel };

package/dist/src/server/runServer.js

@@ -1,40 +0,0 @@
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
-import { container } from '../injection/index.js';
-import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.js';
-import { prepareChatContainer } from './prepareChatContainer.js';
-
-function runServer(config) {
-    for (const provider of config.providers ?? []) {
-        if (provider.singleton) {
-            container.registerSingleton(provider.replace, provider.with);
-        }
-        else {
-            container.register(provider.replace, provider.with);
-        }
-    }
-    const metadataStore = container.resolve(ControllerMetadataStore);
-    for (const controllerCtor of config.controllers) {
-        const chatControllerMetadata = metadataStore.getChatControllerMetadata(controllerCtor);
-        if (!chatControllerMetadata) {
-            continue;
-        }
-        for (const channelMetadata of chatControllerMetadata.channels) {
-            const channelContainer = container.createChildContainer();
-            if (channelMetadata.channelConfig) {
-                channelContainer.register(channelMetadata.channelConfig.constructor, {
-                    useValue: channelMetadata.channelConfig,
-                });
-            }
-            const channel = channelContainer.resolve(channelMetadata.channelConstructor);
-            channel.listen(async (messageContext) => {
-                const chatContainer = await prepareChatContainer(channelContainer, messageContext);
-                const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
-                chatController[channelMetadata.functionName](messageContext);
-            });
-            channel.connect();
-        }
-    }
-}
-
-export { runServer };