@wabot-dev/framework 0.0.8 → 0.0.10

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -50,29 +50,30 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     mapChatItems(chatItems) {
         const openIaInput = [];
         for (const item of chatItems) {
-            if (item.type === 'CONNECTION_MESSAGE') {
-                if (!item.content.text) {
+            const itemData = item.getData();
+            if (itemData.type === 'CONNECTION_MESSAGE') {
+                if (!itemData.content.text) {
                     throw new Error('System message content is empty');
                 }
-                openIaInput.push({ role: 'user', content: item.content.text });
+                openIaInput.push({ role: 'user', content: itemData.content.text });
             }
-            else if (item.type === 'BOT_MESSAGE') {
-                if (!item.content.text) {
+            else if (itemData.type === 'BOT_MESSAGE') {
+                if (!itemData.content.text) {
                     throw new Error('System message content is empty');
                 }
-                openIaInput.push({ role: 'assistant', content: item.content.text });
+                openIaInput.push({ role: 'assistant', content: itemData.content.text });
             }
-            if (item.type === 'FUNCTION_CALL') {
+            if (itemData.type === 'FUNCTION_CALL') {
                 openIaInput.push({
                     type: 'function_call',
-                    call_id: item.content.id,
-                    name: item.content.name,
-                    arguments: JSON.stringify(item.content.arguments),
+                    call_id: itemData.content.id,
+                    name: itemData.content.name,
+                    arguments: JSON.stringify(itemData.content.arguments),
                 });
                 openIaInput.push({
                     type: 'function_call_output',
-                    call_id: item.content.id,
-                    output: item.content.result,
+                    call_id: itemData.content.id,
+                    output: itemData.content.result,
                 });
             }
         }

package/dist/src/channels/cmd/CmdChannel.js

@@ -3,7 +3,6 @@ import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import { v4 } from 'uuid';
 import '../../core/chat/repository/ram/RamChatRepository.js';
 import '../../core/chat/repository/IChatRepository.js';
 import '../../core/user/repository/ram/RamUserRepository.js';
@@ -11,8 +10,8 @@ import '../../core/user/repository/IUserRepository.js';
 import * as readline from 'readline';
 
 var CmdChannel_1;
-const chatId = v4();
-const userId = v4();
+const chatId = 'cmd';
+const userId = 'cmd';
 let CmdChannel = CmdChannel_1 = class CmdChannel {
     chatResolver;
     userResolver;
@@ -30,6 +29,7 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
     }
     connect() {
         this.rl.on('line', async (input) => {
+            debugger;
             const trimmedInput = input.trim();
             if (!trimmedInput) {
                 this.rl.prompt();

package/dist/src/chatbot/ChatBot.js

@@ -1,11 +1,11 @@
 import { __decorate, __metadata } from 'tslib';
+import { ChatItem } from '../core/chat/ChatItem.js';
 import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
 import '../core/chat/repository/ram/RamChatRepository.js';
 import '../core/chat/repository/IChatRepository.js';
 import '../core/user/repository/ram/RamUserRepository.js';
 import '../core/user/repository/IUserRepository.js';
 import { injectable } from '../injection/index.js';
-import { v4 } from 'uuid';
 import { ChatBotAdapter } from './ChatBotAdapter.js';
 
 let ChatBot = class ChatBot {
@@ -17,13 +17,11 @@ let ChatBot = class ChatBot {
         this.memory = memory;
     }
     async sendMessage(message, callback) {
-        const newChatItem = {
-            id: v4(),
-            createdAt: new Date(),
+        const newChatItem = new ChatItem({
             type: 'CONNECTION_MESSAGE',
             content: message,
-        };
-        await this.memory.saveItem(newChatItem);
+        });
+        await this.memory.create(newChatItem);
         this.processLoop(callback);
     }
     async processLoop(callback) {
@@ -32,13 +30,15 @@ let ChatBot = class ChatBot {
             return;
         }
         const lastChatItem = prevChatItems[prevChatItems.length - 1];
-        if (lastChatItem.type === 'BOT_MESSAGE') {
+        const lastItemType = lastChatItem.getType();
+        if (lastItemType === 'BOT_MESSAGE') {
             return;
         }
         const newChatItem = await this.adapter.generateNextChatItem(prevChatItems);
-        await this.memory.saveItem(newChatItem);
-        if (newChatItem.type === 'BOT_MESSAGE') {
-            callback(newChatItem.content);
+        await this.memory.create(newChatItem);
+        const newChatItemData = newChatItem.getData();
+        if (newChatItemData.type === 'BOT_MESSAGE') {
+            callback(newChatItemData.content);
             return;
         }
         this.processLoop(callback);

package/dist/src/chatbot/ChatBotAdapter.js

@@ -1,12 +1,12 @@
-import 'reflect-metadata';
-import '../injection/index.js';
-import '../mindset/metadata/MindsetMetadataStore.js';
-import '../mindset/MindsetOperator.js';
-import { v4 } from 'uuid';
+import { ChatItem } from '../core/chat/ChatItem.js';
 import '../core/chat/repository/ram/RamChatRepository.js';
 import '../core/chat/repository/IChatRepository.js';
 import '../core/user/repository/ram/RamUserRepository.js';
 import '../core/user/repository/IUserRepository.js';
+import 'reflect-metadata';
+import '../injection/index.js';
+import '../mindset/metadata/MindsetMetadataStore.js';
+import '../mindset/MindsetOperator.js';
 
 class ChatBotAdapter {
     mindset;
@@ -51,22 +51,18 @@ class ChatBotAdapter {
     }
     async buildBotMessageItem(text) {
         const senderName = (await this.mindset.identity()).name;
-        const newBotMessage = {
-            id: v4(),
-            createdAt: new Date(),
+        const newBotMessage = new ChatItem({
             type: 'BOT_MESSAGE',
             content: {
                 senderName,
                 text,
             },
-        };
+        });
         return newBotMessage;
     }
     async buildFunctionCallItem(id, functionName, functionArguments) {
         const functionResult = await this.mindset.callFunction(functionName, functionArguments);
-        const newFunctionCall = {
-            id: v4(),
-            createdAt: new Date(),
+        const newFunctionCall = new ChatItem({
             type: 'FUNCTION_CALL',
             content: {
                 id,
@@ -74,7 +70,7 @@ class ChatBotAdapter {
                 arguments: functionArguments,
                 result: functionResult,
             },
-        };
+        });
         return newFunctionCall;
     }
 }

package/dist/src/core/chat/Chat.js

@@ -1,7 +1,8 @@
-class Chat {
-    data;
+import { Persistent } from '../../shared/Persistent.js';
+
+class Chat extends Persistent {
     constructor(data) {
-        this.data = data;
+        super(data);
     }
     isPrivate() {
         return this.data.type === 'PRIVATE';
@@ -27,22 +28,8 @@ class Chat {
             throw new Error('GROUP chat should have exactly one connection');
         }
     }
-    getId() {
-        if (!this.data.id) {
-            throw new Error('Chat ID is required');
-        }
-        return this.data.id;
-    }
-    wasCreated() {
-        return !!this.data.createdAt || !!this.data.id;
-    }
     validate() {
-        if (!this.data.id) {
-            throw new Error('Chat ID is required');
-        }
-        if (!this.data.createdAt) {
-            throw new Error('Chat createdAt is required');
-        }
+        super.validate();
         if (this.data.type === 'PRIVATE') {
             this.validatePrivateChat();
         }

package/dist/src/core/chat/ChatItem.js

@@ -0,0 +1,15 @@
+import { Persistent } from '../../shared/Persistent.js';
+
+class ChatItem extends Persistent {
+    getType() {
+        return this.data.type;
+    }
+    getContent() {
+        return this.data.content;
+    }
+    getData() {
+        return this.data;
+    }
+}
+
+export { ChatItem };

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

@@ -2,7 +2,7 @@ class ChatMemory {
     findLastItems(count) {
         throw new Error('Method not implemented.');
     }
-    saveItem(item) {
+    create(item) {
         throw new Error('Method not implemented.');
     }
 }

package/dist/src/core/chat/repository/ram/RamChatMemory.js

@@ -3,7 +3,7 @@ class RamChatMemory {
     async findLastItems(count) {
         return this.memory.slice(-count);
     }
-    async saveItem(item) {
+    async create(item) {
         this.memory.push(item);
     }
     async clearMemory() {

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

@@ -1,13 +1,8 @@
-class User {
-    data;
+import { Persistent } from '../../shared/Persistent.js';
+
+class User extends Persistent {
     constructor(data) {
-        this.data = data;
-    }
-    getId() {
-        if (!this.data.id) {
-            throw new Error('User have not ID');
-        }
-        return this.data.id;
+        super(data);
     }
     hasConnection(connection) {
         for (const con of this.data.connections) {
@@ -17,17 +12,6 @@ class User {
         }
         return false;
     }
-    wasCreated() {
-        return !!this.data.createdAt || !!this.data.id;
-    }
-    validate() {
-        if (!this.data.id) {
-            throw new Error('User ID is required');
-        }
-        if (!this.data.createdAt) {
-            throw new Error('User createdAt is required');
-        }
-    }
     getValue(key) {
         return this.data.keyValueData[key];
     }

package/dist/src/index.d.ts

@@ -4,6 +4,8 @@ import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options
 import * as tsyringe from 'tsyringe';
 import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
+import { Database } from 'sqlite';
+import sqlite3 from 'sqlite3';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -23,6 +25,28 @@ interface IMindsetFunctionDecoration {
 
 type IConstructor<T> = new (...args: any[]) => T;
 
+interface IReversibleMapper<T1, T2> {
+    map(input: T1): T2;
+    rev(input: T2): T1;
+}
+
+interface IPersistent {
+    id?: string;
+    createdAt?: Date | null;
+    discardedAt?: Date | null;
+}
+declare class Persistent<D extends IPersistent> {
+    protected data: D;
+    private originalData;
+    constructor(data: D);
+    getId(): string;
+    getCreatedAt(): Date;
+    update(newData: D): void;
+    wasCreated(): boolean;
+    validate(): void;
+    discard(): void;
+}
+
 interface IMindsetIdentity {
     name: string;
     language: string;
@@ -192,22 +216,17 @@ interface IChatConnection {
     channelName: string;
     id: string;
 }
-interface IChatData {
-    id?: string;
-    createdAt?: Date;
+interface IChatData extends IPersistent {
     type: IChatType;
     connections: IChatConnection[];
 }
-declare class Chat {
-    private data;
+declare class Chat extends Persistent<IChatData> {
     constructor(data: IChatData);
     isPrivate(): boolean;
     isGroup(): boolean;
     hasConnection(connection: IChatConnection): boolean;
     private validatePrivateChat;
     private validateGroupChat;
-    getId(): string;
-    wasCreated(): boolean;
     validate(): void;
 }
 
@@ -221,22 +240,16 @@ interface IUserConnection {
     channelName: string;
     id: string;
 }
-interface IUserData {
-    id?: string;
-    createdAt?: Date;
+interface IUserData extends IPersistent {
     shortName: string;
     connections: IUserConnection[];
     keyValueData: {
         [key: string]: string;
     };
 }
-declare class User {
-    private data;
+declare class User extends Persistent<IUserData> {
     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;
@@ -273,25 +286,30 @@ type ISystemFunctionCallItem = {
     type: 'FUNCTION_CALL';
     content: IChatFunctionCall;
 };
-type IChatItem = {
-    id: string;
-    createdAt: Date;
+type IChatItemData = {
+    id?: string;
+    createdAt?: Date;
 } & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
-type IChatItemType = IChatItem['type'];
+type IChatItemType = IChatItemData['type'];
+declare class ChatItem extends Persistent<IChatItemData> {
+    getType(): "BOT_MESSAGE" | "CONNECTION_MESSAGE" | "FUNCTION_CALL";
+    getContent(): IChatMessage | IConnectionChatMessage | IChatFunctionCall;
+    getData(): IChatItemData;
+}
 
 interface IChatMemory {
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
 }
 declare class ChatMemory implements IChatMemory {
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
 }
 
 declare class RamChatMemory implements IChatMemory {
     private memory;
-    findLastItems(count: number): Promise<IChatItem[]>;
-    saveItem(item: IChatItem): Promise<void>;
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
     clearMemory(): Promise<void>;
 }
 
@@ -346,28 +364,15 @@ declare class MessageContext implements IMessageContext {
 }
 
 interface IChatBotAdapter {
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
 }
 declare class ChatBotAdapter implements IChatBotAdapter {
     protected mindset: MindsetOperator;
     constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
     protected systemPrompt(): Promise<string>;
-    protected buildBotMessageItem(text: string): Promise<{
-        id: string;
-        createdAt: Date;
-    } & ISystemMessageItem>;
-    protected buildFunctionCallItem(id: string, functionName: string, functionArguments: string): Promise<{
-        readonly id: string;
-        readonly createdAt: Date;
-        readonly type: "FUNCTION_CALL";
-        readonly content: {
-            readonly id: string;
-            readonly name: string;
-            readonly arguments: string;
-            readonly result: string;
-        };
-    }>;
+    protected buildBotMessageItem(text: string): Promise<ChatItem>;
+    protected buildFunctionCallItem(id: string, functionName: string, functionArguments: string): Promise<ChatItem>;
 }
 
 interface IChatBot {
@@ -386,7 +391,7 @@ declare class OpenaiChatBotAdapter extends ChatBotAdapter {
     private openai;
     private model;
     constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
     private mapChatItems;
 }
 
@@ -547,4 +552,52 @@ declare class RegisterUserModule {
     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 };
+interface ICrudRepository<T> {
+    find(id: string): Promise<T | null>;
+    findAll(id: string): Promise<T[]>;
+    create(item: T): Promise<void>;
+    update(item: T): Promise<void>;
+    discard(item: T): Promise<void>;
+}
+
+declare class SqliteCrudRepository<P extends Persistent<IPersistent>> implements ICrudRepository<P> {
+    private table;
+    private dbPath;
+    private mapper;
+    private tableCreated;
+    constructor(table: string, dbPath: string, mapper: IReversibleMapper<P, string>);
+    find(id: string): Promise<P | null>;
+    findAll(): Promise<P[]>;
+    create(item: P): Promise<void>;
+    update(item: P): Promise<void>;
+    discard(item: P): Promise<void>;
+    protected getDb(): Promise<Database<sqlite3.Database, sqlite3.Statement>>;
+    protected createTable(db: Database<sqlite3.Database, sqlite3.Statement>): Promise<void>;
+}
+
+declare class SqliteChatMemory extends SqliteCrudRepository<ChatItem> implements IChatMemory {
+    private chatId;
+    constructor(chatId: string);
+    findLastItems(count: number): Promise<ChatItem[]>;
+    static getDbPath(chatId: string): string;
+}
+
+declare class SqliteChatRepository extends SqliteCrudRepository<Chat> implements IChatRepository {
+    constructor();
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+    static getDbPath(): string;
+}
+
+declare class SqliteUserRepository extends SqliteCrudRepository<User> implements IUserRepository {
+    constructor();
+    findByConnection(query: IUserConnection): Promise<User | null>;
+    static getDbPath(): string;
+}
+
+interface ISqliteRecord {
+    id: string;
+    data: string;
+}
+
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, 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 IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, 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 IPersistent, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, 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, Persistent, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqliteUserRepository, 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

@@ -10,6 +10,7 @@ export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.j
 export { MINDSET_FUNCTION_DECORATION_FUNCTION } from './mindset/metadata/functions/decoratorNames.js';
 export { mindset } from './mindset/metadata/mindsets/@mindset.js';
 export { MINDSET_DECORATION_MINDSET } from './mindset/metadata/mindsets/decoratorNames.js';
+export { Persistent } from './shared/Persistent.js';
 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';
@@ -25,6 +26,7 @@ export { RamChatRepository } from './core/chat/repository/ram/RamChatRepository.
 export { ChatMemory } from './core/chat/repository/IChatMemory.js';
 export { ChatRepository } from './core/chat/repository/IChatRepository.js';
 export { Chat } from './core/chat/Chat.js';
+export { ChatItem } from './core/chat/ChatItem.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';
@@ -37,11 +39,15 @@ 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 { SendOneTimePasswordRequest } from './pre-made/module/authentication/requests/SendOneTimePasswordRequest.js';
+export { ValidateOneTimePasswordRequest } from './pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.js';
+export { AuthenticationModule } from './pre-made/module/authentication/AuthenticationModule.js';
+export { RegisterUserWithEmailRequest } from './pre-made/module/register-user/requests/RegisterUserWithEmailRequest.js';
+export { RegisterUserModule } from './pre-made/module/register-user/RegisterUserModule.js';
+export { EmailService } from './pre-made/service/EmailService.js';
+export { OtpService } from './pre-made/service/OtpService.js';
+export { SqliteChatMemory } from './pre-made/repository/sqlite/chat/SqliteChatMemory.js';
+export { SqliteChatRepository } from './pre-made/repository/sqlite/chat/SqliteChatRepository.js';
+export { SqliteUserRepository } from './pre-made/repository/sqlite/user/SqliteUserRepository.js';
+export { SqliteCrudRepository } from './pre-made/repository/sqlite/SqliteCrudRepository.js';
 export { Container } from './injection/Container.js';

package/dist/src/pre-made/{modules → module}/authentication/AuthenticationModule.js

@@ -10,8 +10,8 @@ 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 { EmailService } from '../../service/EmailService.js';
+import { OtpService } from '../../service/OtpService.js';
 import { SendOneTimePasswordRequest } from './requests/SendOneTimePasswordRequest.js';
 import { ValidateOneTimePasswordRequest } from './requests/ValidateOneTimePasswordRequest.js';
 

package/dist/src/pre-made/repository/sqlite/SqliteCrudRepository.js

@@ -0,0 +1,85 @@
+import { promises } from 'fs';
+import path from 'path';
+import { open } from 'sqlite';
+import sqlite3 from 'sqlite3';
+import { v4 } from 'uuid';
+
+class SqliteCrudRepository {
+    table;
+    dbPath;
+    mapper;
+    tableCreated = false;
+    constructor(table, dbPath, mapper) {
+        this.table = table;
+        this.dbPath = dbPath;
+        this.mapper = mapper;
+    }
+    async find(id) {
+        const db = await this.getDb();
+        const result = await db.all(`SELECT id, data FROM ${this.table} WHERE id=?`, [
+            id,
+        ]);
+        db.close();
+        if (result.length < 1) {
+            return null;
+        }
+        const item = this.mapper.rev(result[0].data);
+        return item;
+    }
+    async findAll() {
+        const db = await this.getDb();
+        const result = await db.all(`SELECT id, data FROM ${this.table}`);
+        db.close();
+        const items = result.map((item) => this.mapper.rev(item.data));
+        return items;
+    }
+    async create(item) {
+        if (item.wasCreated()) {
+            throw new Error('Item already created');
+        }
+        item['data'].id = v4();
+        item['data'].createdAt = new Date();
+        item.validate();
+        const db = await this.getDb();
+        await db.run(`INSERT INTO ${this.table} VALUES (?, ?, ?)`, [
+            item.getId(),
+            item.getCreatedAt().getTime(),
+            this.mapper.map(item),
+        ]);
+        db.close();
+    }
+    async update(item) {
+        if (!item.wasCreated()) {
+            throw new Error('Item is not created');
+        }
+        item.validate();
+        const db = await this.getDb();
+        await db.run(`UPDATE ${this.table} SET data=? WHERE id=?`, [
+            this.mapper.map(item),
+            item.getId(),
+        ]);
+        db.close();
+    }
+    async discard(item) {
+        item.discard();
+        await this.update(item);
+    }
+    async getDb() {
+        const dbDirPath = path.dirname(this.dbPath);
+        await promises.mkdir(dbDirPath, { recursive: true });
+        const db = await open({
+            filename: this.dbPath,
+            driver: sqlite3.Database,
+        });
+        if (!this.tableCreated) {
+            this.tableCreated = true;
+            await this.createTable(db);
+        }
+        return db;
+    }
+    async createTable(db) {
+        await db.exec(`CREATE TABLE IF NOT EXISTS ${this.table}(id TEXT, created_at INTEGER, data TEXT)`);
+    }
+}
+
+export { SqliteCrudRepository };

package/dist/src/pre-made/repository/sqlite/chat/SqliteChatMemory.js

@@ -0,0 +1,35 @@
+import path from 'path';
+import { ChatItem } from '../../../../core/chat/ChatItem.js';
+import '../../../../core/chat/repository/ram/RamChatRepository.js';
+import '../../../../core/chat/repository/IChatRepository.js';
+import '../../../../core/user/repository/ram/RamUserRepository.js';
+import '../../../../core/user/repository/IUserRepository.js';
+import { SqliteCrudRepository } from '../SqliteCrudRepository.js';
+
+const chatItemSqliteMapper = {
+    map(input) {
+        return JSON.stringify(input['data']);
+    },
+    rev(input) {
+        const data = JSON.parse(input);
+        data.createdAt = new Date(data.createdAt);
+        data.discardedAt = data.discardedAt && new Date(data.discardedAt);
+        return new ChatItem(data);
+    },
+};
+class SqliteChatMemory extends SqliteCrudRepository {
+    chatId;
+    constructor(chatId) {
+        super('chat_item', SqliteChatMemory.getDbPath(chatId), chatItemSqliteMapper);
+        this.chatId = chatId;
+    }
+    async findLastItems(count) {
+        const allItems = await this.findAll();
+        return allItems.slice(allItems.length - count, allItems.length);
+    }
+    static getDbPath(chatId) {
+        return path.join(process.cwd(), '.sqlite', 'chat-memory', chatId + '.db');
+    }
+}
+
+export { SqliteChatMemory };

package/dist/src/pre-made/repository/sqlite/chat/SqliteChatRepository.js

@@ -0,0 +1,40 @@
+import '../../../../core/chat/repository/ram/RamChatRepository.js';
+import '../../../../core/chat/repository/IChatRepository.js';
+import { Chat } from '../../../../core/chat/Chat.js';
+import '../../../../core/user/repository/ram/RamUserRepository.js';
+import '../../../../core/user/repository/IUserRepository.js';
+import path from 'path';
+import { SqliteCrudRepository } from '../SqliteCrudRepository.js';
+import { SqliteChatMemory } from './SqliteChatMemory.js';
+
+const chatSqliteMapper = {
+    map(input) {
+        return JSON.stringify(input['data']);
+    },
+    rev(input) {
+        const data = JSON.parse(input);
+        data.createdAt = new Date(data.createdAt);
+        data.discardedAt = data.discardedAt && new Date(data.discardedAt);
+        return new Chat(data);
+    },
+};
+class SqliteChatRepository extends SqliteCrudRepository {
+    constructor() {
+        super('chat', SqliteChatRepository.getDbPath(), chatSqliteMapper);
+    }
+    async findByConnection(query) {
+        const allChats = await this.findAll();
+        return allChats.find((chat) => chat.hasConnection(query)) ?? null;
+    }
+    async findMemory(chatId) {
+        const chat = await this.find(chatId);
+        if (!chat)
+            return null;
+        return new SqliteChatMemory(chatId);
+    }
+    static getDbPath() {
+        return path.join(process.cwd(), '.sqlite', 'chat.db');
+    }
+}
+
+export { SqliteChatRepository };

package/dist/src/pre-made/repository/sqlite/user/SqliteUserRepository.js

@@ -0,0 +1,33 @@
+import '../../../../core/chat/repository/ram/RamChatRepository.js';
+import '../../../../core/chat/repository/IChatRepository.js';
+import { User } from '../../../../core/user/User.js';
+import '../../../../core/user/repository/ram/RamUserRepository.js';
+import '../../../../core/user/repository/IUserRepository.js';
+import path from 'path';
+import { SqliteCrudRepository } from '../SqliteCrudRepository.js';
+
+const userSqliteMapper = {
+    map(input) {
+        return JSON.stringify(input['data']);
+    },
+    rev(input) {
+        const data = JSON.parse(input);
+        data.createdAt = new Date(data.createdAt);
+        data.discardedAt = data.discardedAt && new Date(data.discardedAt);
+        return new User(data);
+    },
+};
+class SqliteUserRepository extends SqliteCrudRepository {
+    constructor() {
+        super('user', SqliteUserRepository.getDbPath(), userSqliteMapper);
+    }
+    async findByConnection(query) {
+        const allItems = await this.findAll();
+        return allItems.find((item) => item.hasConnection(query)) ?? null;
+    }
+    static getDbPath() {
+        return path.join(process.cwd(), '.sqlite', 'user.db');
+    }
+}
+
+export { SqliteUserRepository };

package/dist/src/shared/Persistent.js

@@ -0,0 +1,39 @@
+class Persistent {
+    data;
+    originalData;
+    constructor(data) {
+        this.data = data;
+        this.originalData = { ...data };
+    }
+    getId() {
+        if (!this.data.id) {
+            throw new Error('id is required');
+        }
+        return this.data.id;
+    }
+    getCreatedAt() {
+        if (!this.data.createdAt) {
+            throw new Error('createdAt is required');
+        }
+        return this.data.createdAt;
+    }
+    update(newData) {
+        this.data = newData;
+    }
+    wasCreated() {
+        return !!this.data.createdAt || !!this.data.id;
+    }
+    validate() {
+        if (!this.data.id) {
+            throw new Error('id is required');
+        }
+        if (!this.data.createdAt) {
+            throw new Error('createdAt is required');
+        }
+    }
+    discard() {
+        this.data.discardedAt = new Date();
+    }
+}
+
+export { Persistent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -35,6 +35,7 @@
     "typescript": "5.8.3"
   },
   "peerDependencies": {
+    "@yucacodes/ts": "^0.0.4",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "dotenv": "^16.5.0",
@@ -43,11 +44,9 @@
     "openai": "^4.93.0",
     "reflect-metadata": "^0.2.2",
     "sqlite": "^5.1.1",
-    "sqlite3": "npm:sqlite3-offline-next@^5.0.3",
-    "sqlite3-offline-next": "^5.0.3",
+    "sqlite3": "^5.1.7",
     "tslib": "^2.8.1",
     "tsyringe": "^4.9.1",
-    "uuid": "^11.1.0",
-    "@yucacodes/ts": "^0.0.4"
+    "uuid": "^11.1.0"
   }
 }