@wabot-dev/framework 0.0.11 → 0.0.13

package/dist/src/pre-made/repository/chat/pg/PgChatMemory.js

@@ -0,0 +1,43 @@
+import { ChatItem } from '../../../../core/chat/ChatItem.js';
+import '../../../../core/chat/repository/IChatRepository.js';
+import '../../../../core/user/IUserRepository.js';
+import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import 'fs';
+import 'path';
+import 'sqlite';
+import 'sqlite3';
+import 'uuid';
+import 'pg';
+
+class PgChatMemory extends PgCrudRepository {
+    chatId;
+    constructor(pool, chatId) {
+        super(pool, {
+            table: 'chat_item',
+            schema: 'wabot',
+            constructor: ChatItem,
+            add: {
+                columns: {
+                    chat_id: {
+                        type: 'TEXT',
+                        value: () => chatId,
+                    },
+                },
+            },
+        });
+        this.chatId = chatId;
+    }
+    async findLastItems(count) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE chat_id = $1
+        ORDER BY created_at DESC
+      LIMIT $2
+    `;
+        const items = await this.query(sql, [this.chatId, count]);
+        return items.reverse();
+    }
+}
+
+export { PgChatMemory };

package/dist/src/pre-made/repository/chat/pg/PgChatRepository.js

@@ -0,0 +1,42 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../../core/chat/repository/IChatRepository.js';
+import { Chat } from '../../../../core/chat/Chat.js';
+import '../../../../core/user/IUserRepository.js';
+import { singleton } from '../../../../injection/index.js';
+import { Pool } from 'pg';
+import { PgChatMemory } from './PgChatMemory.js';
+import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import 'fs';
+import 'path';
+import 'sqlite';
+import 'sqlite3';
+import 'uuid';
+
+let PgChatRepository = class PgChatRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            table: 'chat',
+            schema: 'wabot',
+            constructor: Chat,
+        });
+    }
+    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;
+    }
+    async findMemory(chatId) {
+        return new PgChatMemory(this.pool, chatId);
+    }
+};
+PgChatRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgChatRepository);
+
+export { PgChatRepository };

package/dist/src/{core/chat/repository → pre-made/repository/chat}/ram/RamChatRepository.js

@@ -1,6 +1,5 @@
 import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
-import '../IChatRepository.js';
 import { RamChatMemory } from './RamChatMemory.js';
 import { singleton } from '../../../../injection/index.js';
 

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

@@ -1,11 +1,11 @@
 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';
-import { sqliteMapperFor } from '../SqlitePersistentMapper.js';
+import '../../../../core/user/IUserRepository.js';
+import 'pg';
+import 'short-uuid';
+import { SqliteCrudRepository } from '../../../../repository/sqlite/SqliteCrudRepository.js';
+import { sqliteMapperFor } from '../../../../repository/sqlite/SqlitePersistentMapper.js';
 
 class SqliteChatMemory extends SqliteCrudRepository {
     constructor(chatId) {

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

@@ -1,12 +1,12 @@
-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 '../../../../core/user/IUserRepository.js';
 import path from 'path';
-import { SqliteCrudRepository } from '../SqliteCrudRepository.js';
-import { sqliteMapperFor } from '../SqlitePersistentMapper.js';
 import { SqliteChatMemory } from './SqliteChatMemory.js';
+import 'pg';
+import 'short-uuid';
+import { SqliteCrudRepository } from '../../../../repository/sqlite/SqliteCrudRepository.js';
+import { sqliteMapperFor } from '../../../../repository/sqlite/SqlitePersistentMapper.js';
 
 class SqliteChatRepository extends SqliteCrudRepository {
     constructor() {

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

@@ -0,0 +1,38 @@
+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 'fs';
+import 'path';
+import 'sqlite';
+import 'sqlite3';
+import 'uuid';
+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/{core/user/repository → pre-made/repository/user}/ram/RamUserRepository.js

@@ -1,6 +1,5 @@
 import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
-import '../IUserRepository.js';
 import { singleton } from '../../../../injection/index.js';
 
 let RamUserRepository = class RamUserRepository {

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

@@ -0,0 +1,23 @@
+import '../../../../core/chat/repository/IChatRepository.js';
+import { User } from '../../../../core/user/User.js';
+import '../../../../core/user/IUserRepository.js';
+import 'pg';
+import 'short-uuid';
+import { SqliteCrudRepository } from '../../../../repository/sqlite/SqliteCrudRepository.js';
+import { sqliteMapperFor } from '../../../../repository/sqlite/SqlitePersistentMapper.js';
+import path from 'path';
+
+class SqliteUserRepository extends SqliteCrudRepository {
+    constructor() {
+        super('user', SqliteUserRepository.getDbPath(), sqliteMapperFor(User));
+    }
+    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/repository/pg/PgCrudRepository.js

@@ -0,0 +1,63 @@
+import 'pg';
+import * as shortUUID from 'short-uuid';
+import { PgRepositoryBase } from './PgRepositoryBase.js';
+
+class PgCrudRepository extends PgRepositoryBase {
+    config;
+    constructor(pool, config) {
+        super(pool, config);
+        this.config = config;
+    }
+    async find(id) {
+        const sql = `
+      SELECT ${this.columns}
+        FROM ${this.table}
+       WHERE id = $1
+       LIMIT 1
+    `;
+        const items = await this.query(sql, [id]);
+        return items.at(0) ?? null;
+    }
+    async findAll() {
+        const sql = `
+      SELECT ${this.columns}
+        FROM ${this.table}
+    `;
+        const items = await this.query(sql, []);
+        return items;
+    }
+    async create(item) {
+        if (item.wasCreated()) {
+            throw new Error('Item already created');
+        }
+        item['data'].id = shortUUID.default.generate();
+        item['data'].createdAt = new Date().getTime();
+        item.validate();
+        const sql = `
+      INSERT INTO 
+        ${this.table}(${this.columns})
+      VALUES (${this.vars})
+    `;
+        await this.exec(sql, this.values(item));
+    }
+    async update(item) {
+        item.validate();
+        const sql = `
+      UPDATE ${this.table}
+         SET ${this.updates}
+      WHERE id = $${this.columnsList.length + 1}
+    `;
+        await this.exec(sql, [...this.values(item), item.getId()]);
+    }
+    async discard(item) {
+        const _item = await this.find(item.getId());
+        if (!_item) {
+            throw new Error('Not found');
+        }
+        item.discard();
+        _item.discard();
+        await this.update(_item);
+    }
+}
+
+export { PgCrudRepository };

package/dist/src/repository/pg/PgRepositoryBase.js

@@ -0,0 +1,89 @@
+class PgRepositoryBase {
+    pool;
+    config;
+    tableIsCreated = false;
+    schema;
+    table;
+    columnsList;
+    columnsAndTypes;
+    columns;
+    vars;
+    updates;
+    addColumns;
+    constructor(pool, config) {
+        this.pool = pool;
+        this.config = config;
+        this.schema = `"${config.schema ?? 'public'}"`;
+        this.table = [config.schema, config.table]
+            .filter((x) => x && x.trim())
+            .map((x) => `"${x}"`)
+            .join('.');
+        this.addColumns = config.add?.columns ?? {};
+        this.columnsList = ['id', 'created_at', 'data', ...Object.keys(this.addColumns)];
+        this.columnsAndTypes = [
+            '"id" TEXT PRIMARY KEY',
+            '"created_at" TIMESTAMP',
+            '"data" JSONB',
+            ...this.columnsList.slice(3).map((x) => `${x} ${this.addColumns[x].type}`),
+        ].join(', ');
+        this.columns = this.columnsList.map((x) => `"${x}"`).join(', ');
+        this.vars = this.columnsList.map((_, i) => `$${i + 1}`).join(', ');
+        this.updates = this.columnsList.map((x, i) => `"${x}" = $${i + 1}`).join(', ');
+    }
+    values(item) {
+        return [
+            item.getId(),
+            item.getCreatedAt(),
+            JSON.stringify(item['data']),
+            ...this.columnsList.slice(3).map((x) => this.addColumns[x].value(item)),
+        ];
+    }
+    async exec(sql, values) {
+        const conn = await this.connect();
+        await conn.query(sql, values);
+    }
+    async query(sql, values) {
+        const conn = await this.connect();
+        const { rows } = await conn.query(sql, values);
+        return rows.map((row) => new this.config.constructor(row.data));
+    }
+    async connect() {
+        await this.ensureTable();
+        return this.pool;
+    }
+    async ensureTable() {
+        if (this.tableIsCreated) {
+            return;
+        }
+        const schemaQuery = `
+      CREATE SCHEMA IF NOT EXISTS ${this.schema}
+    `;
+        const tableQuery = `
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+      ${this.columnsAndTypes}
+      )
+    `;
+        await this.pool.query(schemaQuery);
+        await this.pool.query(tableQuery);
+        await this.ensureColumns();
+    }
+    async ensureColumns() {
+        const { rows: existing } = await this.pool.query(`
+      SELECT column_name
+      FROM information_schema.columns
+      WHERE table_name = $1 AND table_schema = $2
+    `, [this.config.table, this.config.schema ?? 'public']);
+        const existingColumns = new Set(existing.map((col) => col.column_name));
+        for (let i = 0; i < this.columnsList.length; i++) {
+            const col = this.columnsList[i];
+            const columnAndType = this.columnsAndTypes[0];
+            if (!existingColumns.has(col)) {
+                const alterSql = `ALTER TABLE ${this.table} ADD COLUMN ${columnAndType}`;
+                console.log(`[INFO] Adding column: ${alterSql}`);
+                await this.pool.query(alterSql);
+            }
+        }
+    }
+}
+
+export { PgRepositoryBase };

package/dist/src/server/prepareChatContainer.js

@@ -1,14 +1,12 @@
+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 '../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 '../core/chat/repository/ram/RamChatRepository.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/repository/ram/RamUserRepository.js';
-import '../core/user/repository/IUserRepository.js';
-import { MessageContext } from '../core/IMessageContext.js';
 import 'uuid';
 import { ChatBotMetadataStore } from '../chatbot/metadata/ChatBotMetadataStore.js';
 import { ChatBot } from '../chatbot/ChatBot.js';

package/dist/src/server/runChannel.js

@@ -2,15 +2,13 @@ import dotenv from 'dotenv';
 import '../controller/channel/ChatResolver.js';
 import '../controller/channel/UserResolver.js';
 import { container } from '../injection/index.js';
+import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
+import '../core/user/IUserRepository.js';
 import '../controller/metadata/ControllerMetadataStore.js';
 import 'reflect-metadata';
 import '../mindset/metadata/MindsetMetadataStore.js';
 import '../mindset/MindsetOperator.js';
 import { prepareChatContainer } from './prepareChatContainer.js';
-import '../core/chat/repository/ram/RamChatRepository.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/repository/ram/RamUserRepository.js';
-import '../core/user/repository/IUserRepository.js';
 import 'uuid';
 import '../chatbot/metadata/ChatBotMetadataStore.js';
 import { ChatBot } from '../chatbot/ChatBot.js';

package/dist/src/server/runServer.js

@@ -2,11 +2,9 @@ import dotenv from 'dotenv';
 import '../controller/channel/ChatResolver.js';
 import '../controller/channel/UserResolver.js';
 import { container } from '../injection/index.js';
-import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.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 '../core/user/IUserRepository.js';
+import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.js';
 import { prepareChatContainer } from './prepareChatContainer.js';
 
 dotenv.config();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -45,6 +45,7 @@
     "openai": "^4.93.0",
     "pg": "^8.15.6",
     "reflect-metadata": "^0.2.2",
+    "short-uuid": "^5.2.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
     "tslib": "^2.8.1",

package/dist/src/pre-made/repository/pg/PgCrudRepository.js

@@ -1,70 +0,0 @@
-import 'pg';
-
-class PgCrudRepository {
-    pool;
-    tableName;
-    mapper;
-    tableIsCreated = false;
-    constructor(pool, tableName, mapper) {
-        this.pool = pool;
-        this.tableName = tableName;
-        this.mapper = mapper;
-    }
-    async find(id) {
-        const sql = `
-      SELECT id, data
-        FROM ${this.tableName}
-       WHERE id = $1
-       LIMIT 1
-    `;
-        await this.createTableIfNotExists();
-        const { rows } = await this.pool.query(sql, [id]);
-        if (rows.length === 0)
-            return null;
-        return this.mapper.rev(rows[0].data);
-    }
-    async findAll() {
-        const sql = `SELECT id, data FROM ${this.tableName}`;
-        await this.createTableIfNotExists();
-        const { rows } = await this.pool.query(sql);
-        return rows.map((r) => this.mapper.rev(r.data));
-    }
-    async create(item) {
-        const sql = `
-      INSERT INTO ${this.tableName}(id, data)
-      VALUES ($1, $2)
-    `;
-        const data = this.mapper.map(item);
-        await this.createTableIfNotExists();
-        await this.pool.query(sql, [item.getId(), data]);
-    }
-    async update(item) {
-        const sql = `
-      UPDATE ${this.tableName}
-         SET data = $1
-       WHERE id = $2
-    `;
-        const data = this.mapper.map(item);
-        await this.createTableIfNotExists();
-        await this.pool.query(sql, [data, item.getId()]);
-    }
-    async discard(item) {
-        item.discard();
-        await this.update(item);
-    }
-    async getPool() {
-        await this.createTableIfNotExists();
-        return this.pool;
-    }
-    async createTableIfNotExists() {
-        if (this.tableIsCreated) {
-            return;
-        }
-        await this.pool.query(`CREATE TABLE IF NOT EXISTS ${this.tableName} (
-         id TEXT PRIMARY KEY,
-         data JSONB NOT NULL
-       )`);
-    }
-}
-
-export { PgCrudRepository };

package/dist/src/pre-made/repository/pg/PgPersistentMapper.js

@@ -1,17 +0,0 @@
-class PgPersistentMapper {
-    ctor;
-    constructor(ctor) {
-        this.ctor = ctor;
-    }
-    map(input) {
-        return JSON.stringify(input['data']);
-    }
-    rev(input) {
-        return new this.ctor(JSON.parse(input));
-    }
-}
-function pgMapperFor(ctor) {
-    return new PgPersistentMapper(ctor);
-}
-
-export { PgPersistentMapper, pgMapperFor };

package/dist/src/pre-made/repository/pg/chat/PgChatRepository.js

@@ -1,30 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-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 { Pool } from 'pg';
-import { PgCrudRepository } from '../PgCrudRepository.js';
-import { pgMapperFor } from '../PgPersistentMapper.js';
-import { singleton } from '../../../../injection/index.js';
-
-let PgChatRepository = class PgChatRepository extends PgCrudRepository {
-    constructor(pool) {
-        super(pool, 'chat', pgMapperFor(Chat));
-    }
-    async findByConnection(query) {
-        await this.getPool();
-        throw new Error('Method not implemented.');
-    }
-    async findMemory(chatId) {
-        await this.getPool();
-        throw new Error('Method not implemented.');
-    }
-};
-PgChatRepository = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Pool])
-], PgChatRepository);
-
-export { PgChatRepository };

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

@@ -1,33 +0,0 @@
-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 };