@wabot-dev/framework 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/src/core/chat/repository/IChatMemory.js

@@ -1,10 +0,0 @@
-class ChatMemory {
-    findLastItems(count) {
-        throw new Error('Method not implemented.');
-    }
-    create(item) {
-        throw new Error('Method not implemented.');
-    }
-}
-
-export { ChatMemory };

package/dist/src/core/user/IUserRepository.js

@@ -1,19 +0,0 @@
-import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
-
-let UserRepository = class UserRepository {
-    create(chat) {
-        throw new Error('Method not implemented.');
-    }
-    update(chat) {
-        throw new Error('Method not implemented.');
-    }
-    findByConnection(query) {
-        throw new Error('Method not implemented.');
-    }
-};
-UserRepository = __decorate([
-    singleton()
-], UserRepository);
-
-export { UserRepository };

package/dist/src/core/user/User.js

@@ -1,26 +0,0 @@
-import { Persistent } from '../Persistent.js';
-
-class User extends Persistent {
-    constructor(data) {
-        super(data);
-    }
-    hasConnection(connection) {
-        for (const con of this.data.connections) {
-            if (con.channelName === connection.channelName && con.id === connection.id) {
-                return true;
-            }
-        }
-        return false;
-    }
-    getValue(key) {
-        return this.data.keyValueData[key];
-    }
-    setValue(key, value) {
-        this.data.keyValueData[key] = value;
-    }
-    addConnection(connection) {
-        this.data.connections.push(connection);
-    }
-}
-
-export { User };

package/dist/src/env/WabotEnv.js

@@ -1,27 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from 'tsyringe';
-
-let WabotEnv = class WabotEnv {
-    envType;
-    constructor() {
-        this.envType = process.env.WABOT_ENV ?? 'development';
-    }
-    isDevelopment() {
-        return this.envType === 'development';
-    }
-    isProduction() {
-        return this.envType === 'production';
-    }
-    requireString(varName) {
-        const value = process.env[varName];
-        if (!value)
-            throw new Error(`Env Variable ${varName} is required`);
-        return value;
-    }
-};
-WabotEnv = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [])
-], WabotEnv);
-
-export { WabotEnv };

package/dist/src/injection/index.js

@@ -1,4 +0,0 @@
-await import('reflect-metadata');
-const { injectable, container, singleton, inject } = await import('tsyringe');
-
-export { container, inject, injectable, singleton };

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

@@ -1,21 +0,0 @@
-import 'reflect-metadata';
-import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { container } from '../../../injection/index.js';
-import { PARAM_DECORATION_IS_OPTIONAL } from './decoratorNames.js';
-
-function isOptional() {
-    return (target, propertyKey) => {
-        const paramName = propertyKey.toString();
-        const paramType = Reflect.getMetadata('design:type', target, paramName);
-        const store = container.resolve(MindsetMetadataStore);
-        store.saveParamDecoration({
-            decorationName: PARAM_DECORATION_IS_OPTIONAL,
-            paramType: paramType,
-            paramName: paramName,
-            constructor: target.constructor,
-            decorationConfig: {},
-        });
-    };
-}
-
-export { isOptional };

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

@@ -1,97 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.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 { EmailService } from '../../service/EmailService.js';
-import { OtpService } from '../../service/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 };

package/dist/src/pre-made/module/authentication/requests/SendOneTimePasswordRequest.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 SendOneTimePasswordRequest {
-    fromEmail = '';
-    toEmail = '';
-}
-__decorate([
-    param({
-        description: 'Sender Email address',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "fromEmail", void 0);
-__decorate([
-    param({
-        description: 'Recipient Email Address, to send one time password',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "toEmail", void 0);
-
-export { SendOneTimePasswordRequest };

package/dist/src/pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.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 ValidateOneTimePasswordRequest {
-    userEmail = '';
-    otp = '';
-}
-__decorate([
-    param({
-        description: 'User Email',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "userEmail", void 0);
-__decorate([
-    param({
-        description: 'Otp provided by the User',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "otp", void 0);
-
-export { ValidateOneTimePasswordRequest };

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 };